diff --git a/.vscode/launch.json b/.vscode/launch.json
index b853bc52..e9c38937 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -10,7 +10,7 @@
             "name": "clice_socket",
             "program": "${workspaceFolder}/build/bin/clice",
             "args": [
-                "--config={workspaceFolder}/docs/clice.toml"
+                "--config=${workspaceFolder}/docs/clice.toml"
             ]
         },
         {
@@ -19,7 +19,7 @@
             "name": "clice_test",
             "program": "${workspaceFolder}/build/bin/clice-tests",
             "args": [
-                "--test-dir={workspaceFolder}/tests",
+                "--test-dir=${workspaceFolder}/tests",
                 "${input:filter}"
             ],
         }
diff --git a/deps/llvm b/deps/llvm
index cf991be6..668c8f77 160000
--- a/deps/llvm
+++ b/deps/llvm
@@ -1 +1 @@
-Subproject commit cf991be623559ae58f6d1740cda67095cdeb75ba
+Subproject commit 668c8f77161b29717c63a9e5bc322429ef0aa0ea
diff --git a/include/Basic/Basic.h b/include/Basic/Basic.h
index 64d8a780..f7461325 100644
--- a/include/Basic/Basic.h
+++ b/include/Basic/Basic.h
@@ -3,6 +3,12 @@
 #include <llvm/ADT/StringRef.h>
 #include <llvm/ADT/StringExtras.h>
 
+namespace clice {
+
+class Compiler;
+
+}
+
 namespace clice::proto {
 
 /// range in [-2^31, 2^31- 1]
diff --git a/include/Compiler/Resolver.h b/include/Compiler/Resolver.h
index c2a46c0b..005645e3 100644
--- a/include/Compiler/Resolver.h
+++ b/include/Compiler/Resolver.h
@@ -43,14 +43,31 @@ public:
         return lookup(expr->getQualifier(), expr->getNameInfo().getName());
     }
 
-    /// TODO:
-    clang::lookup_result lookup(clang::CXXDependentScopeMemberExpr* expr);
+    clang::lookup_result lookup(const clang::UnresolvedLookupExpr* expr) {
+        /// FIXME: 
+        for(auto decl: expr->decls()) {
+            if(auto TD = llvm::dyn_cast<clang::TemplateDecl>(decl)) {
+                return clang::lookup_result(TD);
+            }
+        }
 
-    clang::lookup_result lookup(clang::UnresolvedUsingValueDecl* decl) {
+        return {};
+    }
+
+    clang::lookup_result lookup(const clang::UnresolvedMemberExpr* expr) {
+        return {};
+    }
+
+    /// TODO:
+    clang::lookup_result lookup(clang::CXXDependentScopeMemberExpr* expr) {
+        return {};
+    }
+
+    clang::lookup_result lookup(const clang::UnresolvedUsingValueDecl* decl) {
         return lookup(decl->getQualifier(), decl->getDeclName());
     }
 
-    clang::lookup_result resolve(clang::UnresolvedUsingTypenameDecl* decl) {
+    clang::lookup_result resolve(const clang::UnresolvedUsingTypenameDecl* decl) {
         return lookup(decl->getQualifier(), decl->getDeclName());
     }
 
diff --git a/include/Compiler/Semantic.h b/include/Compiler/Semantic.h
index a4138bfc..bb220bac 100644
--- a/include/Compiler/Semantic.h
+++ b/include/Compiler/Semantic.h
@@ -53,12 +53,61 @@ enum class OccurrenceKind {
     Instantiation,
 };
 
-class SemanticVisitor : public clang::RecursiveASTVisitor<SemanticVisitor> {
+template <typename Derived>
+class SemanticVisitor : public clang::RecursiveASTVisitor<SemanticVisitor<Derived>> {
 public:
     using Base = clang::RecursiveASTVisitor<SemanticVisitor>;
 
-    SemanticVisitor(Compiler& compiler) :
-        sema(compiler.sema()), resolver(compiler.resolver()), srcMgr(compiler.srcMgr()) {}
+    SemanticVisitor(Compiler& compiler, bool mainFileOnly = false) :
+        sema(compiler.sema()), resolver(compiler.resolver()), srcMgr(compiler.srcMgr()),
+        tokBuf(compiler.tokBuf()), mainFileOnly(mainFileOnly) {}
+
+public:
+
+public:
+    consteval bool VisitImplicitInstantiation() {
+        return true;
+    }
+
+    Derived& getDerived() {
+        return static_cast<Derived&>(*this);
+    }
+
+    bool needFilter(clang::SourceLocation location) {
+        return location.isInvalid() || (mainFileOnly && !srcMgr.isInMainFile(location));
+    }
+
+    void dump(clang::SourceLocation loc) {
+        auto location = srcMgr.getPresumedLoc(loc);
+        llvm::SmallString<128> path;
+        auto err = fs::real_path(location.getFilename(), path);
+        llvm::outs() << path << ":" << location.getLine() << ":" << location.getColumn() << "\n";
+    }
+
+    /// An occurrence directly corresponding to a symbol in source code.
+    /// In most cases, a location just correspondings to unique decl.
+    /// So a location will be just visited once. But in some other cases,
+    /// a location may correspond to multiple decls. Note that we already
+    /// filter some nodes with invalid location.
+    ///
+    /// 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) {}
+
+    /// 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.
+    /// e.g. `unsigned long long`.
+    void handleOccurrence(const clang::BuiltinType* type,
+                          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) {
+        ///
+    }
 
 public:
     /// ============================================================================
@@ -66,6 +115,10 @@ public:
     /// ============================================================================
 
     TRAVERSE_DECL(Decl) {
+        if(!llvm::isa<clang::TranslationUnitDecl>(decl) && needFilter(decl->getLocation())) {
+            return true;
+        }
+
         decls.push_back(decl);
         auto result = Base::TraverseDecl(decl);
         decls.pop_back();
@@ -75,7 +128,7 @@ public:
     VISIT_DECL(NamespaceDecl) {
         /// `namespace Foo { }`
         ///             ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
@@ -83,43 +136,43 @@ public:
         /// `namespace Foo = Bar`
         ///             ^     ^~~~ reference
         ///             ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
-        handleOccurrence(decl->getNamespace(), decl->getTargetNameLoc());
+        getDerived().handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl->getNamespace(), decl->getTargetNameLoc());
         return true;
     }
 
     VISIT_DECL(UsingDirectiveDecl) {
         /// `using namespace Foo`
         ///                   ^~~~~~~ reference
-        handleOccurrence(decl->getNominatedNamespace(), decl->getLocation());
+        getDerived().handleOccurrence(decl->getNominatedNamespace(), decl->getLocation());
         return true;
     }
 
     VISIT_DECL(LabelDecl) {
         /// `label:`
         ///    ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(FieldDecl) {
         /// `int foo;`
         ///       ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(EnumConstantDecl) {
         /// `enum Foo { bar };`
         ///              ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(UsingDecl) {
         /// `using Foo::bar;`
         ///              ^~~~ reference
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         /// FIXME:
         return true;
     }
@@ -127,55 +180,33 @@ public:
     VISIT_DECL(BindingDecl) {
         /// `auto [a, b] = std::make_tuple(1, 2);`
         ///        ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(TemplateTypeParmDecl) {
         /// `template <typename T>`
         ///                     ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(TemplateTemplateParmDecl) {
         /// `template <template <typename> class T>`
         ///                                      ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(NonTypeTemplateParmDecl) {
         /// `template <int N>`
         ///                ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         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
-        handleOccurrence(decl, decl->getLocation());
-        return true;
-    }
-
-    VISIT_DECL(ClassTemplateDecl) {
-        /// `template <typename T> class Foo { };`
-        ///                               ^~~~ declaration/definition
-        handleOccurrence(decl, decl->getLocation());
-        return true;
-    }
-
-    VISIT_DECL(ClassTemplatePartialSpecializationDecl) {
+        /// FIXME:
         /// 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.
@@ -187,29 +218,34 @@ public:
         /// For explicit instantiation:
         /// `template class Foo<int>;`
         ///                  ^~~~ reference
-        handleOccurrence(decl, decl->getLocation());
+        // if(decl->getDescribedTemplate() ||
+        //    llvm::isa<clang::ClassTemplateSpecializationDecl,
+        //              clang::ClassTemplatePartialSpecializationDecl>(decl)) {
+        //     return true;
+        // }
+
+        /// `struct/class/union/enum Foo { };`
+        ///                           ^~~~ declaration/definition
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(FunctionDecl) {
+        /// FIXME:
         /// 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;
-        }
+        // if(decl->getDescribedFunctionTemplate()) {
+        //     return true;
+        // }
 
         /// `void foo();`
         ///         ^~~~ declaration/definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(FunctionTemplateDecl) {
-        /// `template <typename T> void foo();`
-        ///                               ^~~~ declaration/definition
-        handleOccurrence(decl, decl->getLocation());
-
         /// `template void foo<int>();`
         ///                  ^~~~ reference
 
@@ -236,48 +272,30 @@ public:
     }
 
     VISIT_DECL(TypedefNameDecl) {
-        /// Skip the typedef name declaration that is a type alias template.
-        if(decl->getDescribedTemplate()) {
-            return true;
-        }
-
-        /// `using Foo = int;`
-        ///             ^~~~ declaration/definition
-        handleOccurrence(decl, decl->getLocation());
-        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
-        handleOccurrence(decl, decl->getLocation());
+        /// `using Foo = int;`
+        ///             ^~~~ declaration/definition
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(VarDecl) {
+        /// FIXME:
         /// 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;
-        }
+        // if(decl->getDescribedVarTemplate() ||
+        //    llvm::isa<clang::VarTemplateSpecializationDecl,
+        //              clang::VarTemplatePartialSpecializationDecl>(decl)) {
+        //     return true;
+        // }
 
         /// `int foo;`
         ///       ^~~~ declaration/definition
-        handleOccurrence(decl, decl->getLocation());
-        return true;
-    }
-
-    VISIT_DECL(VarTemplateDecl) {
-        /// `template <typename T> int foo;`
-        ///                             ^~~~ declaration/definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
@@ -293,6 +311,7 @@ public:
             return true;
         }
 
+        /// FIXME:
         /// 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.
@@ -304,21 +323,21 @@ public:
         /// For explicit instantiation:
         /// `template int foo<int>;`
         ///                ^~~~ reference
-        handleOccurrence(decl, decl->getLocation());
+        /// getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     VISIT_DECL(ConceptDecl) {
         /// `template <typename T> concept Foo = ...;`
         ///                                 ^~~~ definition
-        handleOccurrence(decl, decl->getLocation());
+        getDerived().handleOccurrence(decl, decl->getLocation());
         return true;
     }
 
     bool TraverseConceptReference(clang::ConceptReference* reference) {
         /// `requires Foo<T>;`
         ///            ^~~~ reference
-        handleOccurrence(reference->getNamedConcept(), reference->getConceptNameLoc());
+        getDerived().handleOccurrence(reference->getNamedConcept(), reference->getConceptNameLoc());
 
         return Base::TraverseConceptReference(reference);
     }
@@ -332,31 +351,51 @@ public:
         return true;
     }
 
+    bool TraverseTypeLoc(clang::TypeLoc loc) {
+        /// FIXME: Workaround for `QualifiedTypeLoc`.
+        if(auto QL = loc.getAs<clang::QualifiedTypeLoc>()) {
+            return Base::TraverseTypeLoc(QL.getUnqualifiedLoc());
+        }
+
+        if(needFilter(loc.getLocalSourceRange().getBegin())) {
+            return true;
+        }
+
+        return Base::TraverseTypeLoc(loc);
+    }
+
+    VISIT_TYPELOC(BuiltinTypeLoc) {
+        /// `int foo`
+        ///    ^~~~ reference
+        getDerived().handleOccurrence(loc.getTypePtr(), loc.getLocalSourceRange());
+        return true;
+    }
+
     VISIT_TYPELOC(TagTypeLoc) {
         /// `struct Foo { }; Foo foo`
         ///                   ^~~~ reference
-        handleOccurrence(loc.getDecl(), loc.getNameLoc());
+        getDerived().handleOccurrence(loc.getDecl(), loc.getNameLoc());
         return true;
     }
 
     VISIT_TYPELOC(TypedefTypeLoc) {
         /// `using Foo = int; Foo foo`
         ///                    ^~~~ reference
-        handleOccurrence(loc.getTypedefNameDecl(), loc.getNameLoc());
+        getDerived().handleOccurrence(loc.getTypedefNameDecl(), loc.getNameLoc());
         return true;
     }
 
     VISIT_TYPELOC(TemplateTypeParmTypeLoc) {
         /// `template <typename T> void foo(T t)`
         ///                                 ^~~~ reference
-        handleOccurrence(loc.getDecl(), loc.getNameLoc());
+        getDerived().handleOccurrence(loc.getDecl(), loc.getNameLoc());
         return true;
     }
 
     VISIT_TYPELOC(TemplateSpecializationTypeLoc) {
         /// `std::vector<int>`
         ///        ^~~~ reference
-        handleOccurrence(declForType(loc.getType()), loc.getTemplateNameLoc());
+        getDerived().handleOccurrence(declForType(loc.getType()), loc.getTemplateNameLoc());
         return true;
     }
 
@@ -364,7 +403,7 @@ public:
         /// `std::vector<T>::value_type`
         ///                      ^~~~ reference
         for(auto decl: resolver.lookup(loc.getTypePtr())) {
-            handleOccurrence(decl, loc.getNameLoc());
+            getDerived().handleOccurrence(decl, loc.getNameLoc());
         }
         return true;
     }
@@ -373,7 +412,7 @@ public:
         /// `std::allocator<T>::rebind<U>`
         ///                       ^~~~ reference
         for(auto decl: resolver.lookup(loc.getTypePtr())) {
-            handleOccurrence(decl, loc.getTemplateNameLoc());
+            getDerived().handleOccurrence(decl, loc.getTemplateNameLoc());
         }
         return true;
     }
@@ -382,6 +421,30 @@ public:
     ///                                Specifier
     /// ============================================================================
 
+    bool TraverseAttr(clang::Attr* attr) {
+        if(needFilter(attr->getLocation())) {
+            return true;
+        }
+
+        getDerived().handleOccurrence(attr, attr->getLocation());
+
+        return Base::TraverseAttr(attr);
+    }
+
+    /// FIXME: clang currently doesn't traverse attributes in `AttrbutedStmt` correctly.
+    /// See https://github.com/llvm/llvm-project/issues/117687.
+    bool TraverseAttributedStmt(clang::AttributedStmt* stmt) {
+        if(needFilter(stmt->getBeginLoc())) {
+            return true;
+        }
+
+        for(auto attr: stmt->getAttrs()) {
+            getDerived().handleOccurrence(attr, attr->getRange());
+        }
+
+        return Base::TraverseAttributedStmt(stmt);
+    }
+
     bool TraverseCXXBaseSpecifier(const clang::CXXBaseSpecifier& base) {
         return Base::TraverseCXXBaseSpecifier(base);
     }
@@ -392,18 +455,18 @@ public:
     }
 
     bool TraverseNestedNameSpecifierLoc(clang::NestedNameSpecifierLoc loc) {
-        if(!loc) {
+        if(!loc || needFilter(loc.getLocalBeginLoc())) {
             return true;
         }
 
         auto NNS = loc.getNestedNameSpecifier();
         switch(NNS->getKind()) {
             case clang::NestedNameSpecifier::Namespace: {
-                handleOccurrence(NNS->getAsNamespace(), loc.getLocalBeginLoc());
+                getDerived().handleOccurrence(NNS->getAsNamespace(), loc.getLocalBeginLoc());
                 break;
             }
             case clang::NestedNameSpecifier::NamespaceAlias: {
-                handleOccurrence(NNS->getAsNamespaceAlias(), loc.getLocalBeginLoc());
+                getDerived().handleOccurrence(NNS->getAsNamespaceAlias(), loc.getLocalBeginLoc());
                 break;
             }
             case clang::NestedNameSpecifier::Identifier: {
@@ -430,17 +493,41 @@ public:
     ///                                 Statement
     /// ============================================================================
 
+    bool TraverseStmt(clang::Stmt* stmt) {
+        if(stmt && needFilter(stmt->getBeginLoc())) {
+            return true;
+        }
+
+        return Base::TraverseStmt(stmt);
+    }
+
+    VISIT_EXPR(CallExpr) {
+        // TODO: consider lambda expression.
+        return true;
+    }
+
     VISIT_EXPR(DeclRefExpr) {
         /// `foo = 1`
         ///   ^~~~ reference
-        handleOccurrence(expr->getDecl(), expr->getLocation());
+        getDerived().handleOccurrence(expr->getDecl(), expr->getLocation());
         return true;
     }
 
     VISIT_EXPR(MemberExpr) {
         /// `foo.bar`
         ///       ^~~~ reference
-        handleOccurrence(expr->getMemberDecl(), expr->getMemberLoc());
+        getDerived().handleOccurrence(expr->getMemberDecl(), expr->getMemberLoc());
+        return true;
+    }
+
+    VISIT_EXPR(UnresolvedLookupExpr) {
+        /// `std::is_same<T, U>::value`
+        ///           ^~~~ reference
+        for(auto decl: resolver.lookup(expr)) {
+            getDerived().handleOccurrence(decl,
+                                          expr->getNameLoc(),
+                                          OccurrenceKind::PseudoInstantiation);
+        }
         return true;
     }
 
@@ -448,7 +535,7 @@ public:
         /// `std::is_same<T, U>::value`
         ///                        ^~~~ reference
         for(auto decl: resolver.lookup(expr)) {
-            handleOccurrence(decl, expr->getNameInfo().getLoc());
+            getDerived().handleOccurrence(decl, expr->getNameInfo().getLoc());
         }
         return true;
     }
@@ -460,53 +547,12 @@ public:
         return true;
     }
 
-    VISIT_EXPR(CallExpr) {
-        // TODO: consider lambda expression.
-        return true;
-    }
-
-public:
-    consteval bool VisitImplicitInstantiation() {
-        return true;
-    }
-
-    /// An occurrence directly corresponding to a symbol in source code.
-    /// In most cases, a location just correspondings to unique decl.
-    /// So a location will be just visited once. But in some other cases,
-    /// a location may correspond to multiple decls. Note that we already
-    /// filter some nodes with invalid location.
-    ///
-    /// 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) {
-        if(location.isMacroID()) {
-            if(srcMgr.isMacroArgExpansion(location)) {
-                auto spelling = srcMgr.getSpellingLoc(location);
-                dump(spelling);
-                auto expansion = srcMgr.getExpansionLoc(location);
-                dump(expansion);
-                llvm::outs() << "-----------------------------------------------------\n";
-            }
-        }
-    }
-
-    void dump(clang::SourceLocation loc) {
-        auto location = srcMgr.getPresumedLoc(loc);
-        llvm::SmallString<128> path;
-        auto err = fs::real_path(location.getFilename(), path);
-        llvm::outs() << path << ":" << location.getLine() << ":" << location.getColumn() << "\n";
-    }
-
-    /// Always uses expansion location if the original location is a macro location.
-    void handleRelation(const clang::Decl* decl, RelationKind kind, clang::SourceRange range) {
-        ///
-    }
-
-private:
+protected:
     clang::Sema& sema;
     TemplateResolver& resolver;
     clang::SourceManager& srcMgr;
+    clang::syntax::TokenBuffer& tokBuf;
+    bool mainFileOnly;
     llvm::SmallVector<clang::Decl*> decls;
 };
 
diff --git a/include/Feature/SemanticTokens.def b/include/Feature/SemanticTokens.def
index 34e6a9e0..fca7db5c 100644
--- a/include/Feature/SemanticTokens.def
+++ b/include/Feature/SemanticTokens.def
@@ -42,6 +42,12 @@ SEMANTIC_TOKEN_TYPE(Namespace, "namespace")
 /// C/C++ type name (e.g. `std::string`).
 SEMANTIC_TOKEN_TYPE(Type, "type")
 
+/// C/C++ enum name.
+SEMANTIC_TOKEN_TYPE(Enum, "enum")
+
+/// C/C++ enum member name.
+SEMANTIC_TOKEN_TYPE(EnumMember, "enumMember")
+
 /// C/C++ struct name.
 SEMANTIC_TOKEN_TYPE(Struct, "struct")
 
@@ -54,23 +60,20 @@ SEMANTIC_TOKEN_TYPE(Class, "class")
 /// C/C++ field name.
 SEMANTIC_TOKEN_TYPE(Field, "field")
 
-/// C/C++ enum name.
-SEMANTIC_TOKEN_TYPE(Enum, "enum")
-
-/// C/C++ enum member name.
-SEMANTIC_TOKEN_TYPE(EnumMember, "enumMember")
-
 /// C/C++ variable name.
 SEMANTIC_TOKEN_TYPE(Variable, "variable")
 
+/// C/C++ function/method parameter name.
+SEMANTIC_TOKEN_TYPE(Parameter, "parameter")
+
 /// C/C++ function name.
 SEMANTIC_TOKEN_TYPE(Function, "function")
 
 /// C/C++ method name.
 SEMANTIC_TOKEN_TYPE(Method, "method")
 
-/// C/C++ function/method parameter name.
-SEMANTIC_TOKEN_TYPE(Parameter, "parameter")
+/// C/C++ label name.
+SEMANTIC_TOKEN_TYPE(Label, "label")
 
 /// C++ attribute name(e.g., `nodiscard`, `likely`, `fallthrough`).
 SEMANTIC_TOKEN_TYPE(Attribute, "attribute")
diff --git a/include/Feature/SemanticTokens.h b/include/Feature/SemanticTokens.h
index 73bef9d1..f830fab9 100644
--- a/include/Feature/SemanticTokens.h
+++ b/include/Feature/SemanticTokens.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <Basic/Basic.h>
+#include <Basic/Document.h>
 
 namespace clice::proto {
 
@@ -9,6 +9,7 @@ enum class SemanticTokenType : uint8_t {
     #define SEMANTIC_TOKEN_TYPE(name, ...) name,
     #include "SemanticTokens.def"
     #undef SEMANTIC_TOKEN_TYPE
+    Invalid,
     LAST_TYPE
 };
 
@@ -34,18 +35,18 @@ struct SemanticTokensLegend {
 /// Server Capability.
 struct SemanticTokensOptions {
     /// The legend used by the server.
-    SemanticTokensLegend legend;
+    SemanticTokensLegend legend = {};
 
-    /// Server supports providing semantic tokens for a specific range of a document.
+    /// The grammar of C++ is highly context-sensitive, so we only provide semantic tokens for
+    /// the whole document.
     bool range = false;
 
-    /// Server supports providing semantic tokens for a full document.
     bool full = true;
 };
 
 struct SemanticTokensParams {
     /// The text document.
-    /// TextDocumentIdentifier textDocument;
+    TextDocumentIdentifier textDocument;
 };
 
 struct SemanticTokens {
@@ -56,6 +57,9 @@ struct SemanticTokens {
 }  // namespace clice::proto
 
 namespace clice::feature {
-// proto::SemanticTokens semanticTokens(const ParsedAST& AST, llvm::StringRef filename);
+
+/// FIXME:
+proto::SemanticTokens semanticTokens(Compiler& compiler, llvm::StringRef filename);
+
 }  // namespace clice::feature
 
diff --git a/include/Server/Server.h b/include/Server/Server.h
index abbc6f01..a577ca0a 100644
--- a/include/Server/Server.h
+++ b/include/Server/Server.h
@@ -77,7 +77,7 @@ struct InitializeParams {
 struct ServerCapabilities {
     std::string_view positionEncoding = "utf-16";
     TextDocumentSyncKind textDocumentSync = TextDocumentSyncKind::Full;
-    // SemanticTokensOptions semanticTokensProvider;
+    SemanticTokensOptions semanticTokensProvider;
 };
 
 struct InitializeResult {
@@ -303,7 +303,7 @@ private:
 
         struct Task {
             TaskKind kind;
-            async::promise<void> request;
+            llvm::unique_function<async::promise<void>(Compiler&)> request;
         };
 
         State state;
@@ -311,16 +311,11 @@ private:
         std::vector<Task> tasks;
     };
 
-    async::promise<void> schedule(llvm::StringRef path, async::promise<void> request) {
-        auto& unit = units[path];
-        if(unit.state == TranslationUnit::State::Building) {
-            // unit.requests.push_back(std::move(request));
-        } else {
-            co_await request;
-        }
-
-        co_return;
-    }
+    /// 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.
+    async::promise<void> schedule(llvm::StringRef path,
+                                  llvm::unique_function<async::promise<void>(Compiler&)> callback);
 
 private:
     llvm::StringMap<PCH> pchs;
diff --git a/src/Compiler/Compiler.cpp b/src/Compiler/Compiler.cpp
index c23ef8c1..581e595d 100644
--- a/src/Compiler/Compiler.cpp
+++ b/src/Compiler/Compiler.cpp
@@ -28,9 +28,10 @@ Compiler::Compiler(llvm::StringRef filepath,
 
     // FIXME: customize DiagnosticConsumer
     if(consumer) {
-        instance->createDiagnostics(consumer, true);
+        instance->createDiagnostics(*llvm::vfs::getRealFileSystem(), consumer, true);
     } else {
         instance->createDiagnostics(
+            *llvm::vfs::getRealFileSystem(),
             new clang::TextDiagnosticPrinter(llvm::outs(), new clang::DiagnosticOptions()),
             true);
     }
@@ -86,10 +87,8 @@ void Compiler::codeCompletion(llvm::StringRef filepath,
     location.Line = line;
     location.Column = column;
 
-    if(content != "") {
-        auto buffer = llvm::MemoryBuffer::getMemBufferCopy(content);
-        instance->getPreprocessorOpts().addRemappedFile(filepath, buffer.release());
-    }
+    auto buffer = llvm::MemoryBuffer::getMemBufferCopy(content);
+    instance->getPreprocessorOpts().addRemappedFile(filepath, buffer.release());
 
     instance->setCodeCompletionConsumer(consumer);
 
diff --git a/src/Feature/SemanticTokens.cpp b/src/Feature/SemanticTokens.cpp
index d23bbc10..d20b2050 100644
--- a/src/Feature/SemanticTokens.cpp
+++ b/src/Feature/SemanticTokens.cpp
@@ -1,23 +1,14 @@
 // #include "Compiler/ParsedAST.h"
 #include "Feature/SemanticTokens.h"
+#include "Compiler/Semantic.h"
 
 namespace clice::feature {
 
 namespace {
 
-struct SemanticToken {
-    clang::SourceLocation begin;
-    std::size_t length;
-    proto::SemanticTokenType type;
-    std::uint32_t modifiers = 0;
-
-    SemanticToken& addModifier(proto::SemanticTokenModifier modifier) {
-        modifiers |= 1 << static_cast<std::uint32_t>(modifier);
-        return *this;
-    }
-};
-
-static bool isKeyword(clang::tok::TokenKind kind, llvm::StringRef text, const clang::LangOptions& option) {
+static bool isKeyword(clang::tok::TokenKind kind,
+                      llvm::StringRef text,
+                      const clang::LangOptions& option) {
     switch(kind) {
         case clang::tok::kw_void:
         case clang::tok::kw_int:
@@ -168,9 +159,11 @@ static bool isKeyword(clang::tok::TokenKind kind, llvm::StringRef text, const cl
 
 // class HighlightBuilder {//
 // public://
-//     HighlightBuilder(con//st ParsedAST& parsedAST, llvm::StringRef filename) : AST(parsedAST), filename(filename) {}
+//     HighlightBuilder(con//st ParsedAST& parsedAST, llvm::StringRef filename) : AST(parsedAST),
+//     filename(filename) {}
 //
-//     SemanticToken& addToken(proto::SemanticTokenType type, clang::SourceLocation begin, std::size_t length) {
+//     SemanticToken& addToken(proto::SemanticTokenType type, clang::SourceLocation begin,
+//     std::size_t length) {
 //         result.emplace_back(begin, length, type, 0);
 //         return result.back();
 //     }
@@ -187,7 +180,8 @@ static bool isKeyword(clang::tok::TokenKind kind, llvm::StringRef text, const cl
 //     //    SemanticToken token;
 //     //    token.begin = range.getBegin();
 //     //    token.length =
-//     //        AST.sourceManager.getFileOffset(range.getEnd()) - AST.sourceManager.getFileOffset(range.getBegin());
+//     //        AST.sourceManager.getFileOffset(range.getEnd()) -
+//     AST.sourceManager.getFileOffset(range.getBegin());
 //     //    token.type = type;
 //     //    result.emplace_back(std::move(token));
 //     //    return result.back();
@@ -212,10 +206,12 @@ static bool isKeyword(clang::tok::TokenKind kind, llvm::StringRef text, const cl
 //         auto loc = AST.sourceManager.getFileLoc(right);
 //         if(auto token = AST.tokenBuffer.spelledTokenContaining(loc)) {
 //             if(token->kind() == clang::tok::greater) {
-//                 addToken(proto::SemanticTokenType::Angle, loc, 1).addModifier(proto::SemanticTokenModifier::Right);
+//                 addToken(proto::SemanticTokenType::Angle, loc,
+//                 1).addModifier(proto::SemanticTokenModifier::Right);
 //             } else if(token->kind() == clang::tok::greatergreater) {
 //                 // TODO: split `>>` into two tokens
-//                 addToken(proto::SemanticTokenType::Angle, loc, 2).addModifier(proto::SemanticTokenModifier::Right);
+//                 addToken(proto::SemanticTokenType::Angle, loc,
+//                 2).addModifier(proto::SemanticTokenModifier::Right);
 //             }
 //         }
 //     }
@@ -231,7 +227,8 @@ static bool isKeyword(clang::tok::TokenKind kind, llvm::StringRef text, const cl
 ///// Collect highlight information from AST.
 // class HighlightCollector : public clang::RecursiveASTVisitor<HighlightCollector> {
 // public:
-//     HighlightCollector(const ParsedAST& AST, HighlightBuilder& builder) : AST(AST), builder(builder) {}
+//     HighlightCollector(const ParsedAST& AST, HighlightBuilder& builder) : AST(AST),
+//     builder(builder) {}
 //
 //     // Traverse(TranslationUnitDecl) {
 //     //     for(auto decl: node->decls()) {
@@ -447,7 +444,8 @@ static bool isKeyword(clang::tok::TokenKind kind, llvm::StringRef text, const cl
 //                 break;
 //             }
 //             default: {
-//                 if(isKeyword(token.kind(), token.text(AST.sourceManager), AST.context.getLangOpts())) {
+//                 if(isKeyword(token.kind(), token.text(AST.sourceManager),
+//                 AST.context.getLangOpts())) {
 //                     type = proto::SemanticTokenType::Keyword;
 //                     break;
 //                 }
@@ -499,6 +497,155 @@ static bool isKeyword(clang::tok::TokenKind kind, llvm::StringRef text, const cl
 //     return result;
 // };
 //
+
+struct SemanticToken {
+    std::uint32_t line;
+    std::uint32_t column;
+    std::uint32_t length;
+    proto::SemanticTokenType type;
+    std::uint32_t modifiers = 0;
+
+    SemanticToken& addModifier(proto::SemanticTokenModifier modifier) {
+        modifiers |= 1 << static_cast<std::uint32_t>(modifier);
+        return *this;
+    }
+};
+
+class HighlightBuilder : public SemanticVisitor<HighlightBuilder> {
+public:
+    HighlightBuilder(Compiler& compiler) : SemanticVisitor<HighlightBuilder>(compiler, true) {}
+
+    void handleOccurrence(const clang::Decl* decl,
+                          clang::SourceLocation location,
+                          OccurrenceKind kind = OccurrenceKind::Source) {
+        proto::SemanticTokenType type = proto::SemanticTokenType::Invalid;
+        if(llvm::isa<clang::NamespaceDecl, clang::NamespaceAliasDecl>(decl)) {
+            type = proto::SemanticTokenType::Namespace;
+        } else if(llvm::isa<clang::TypedefNameDecl,
+                            clang::TemplateTypeParmDecl,
+                            clang::TemplateTemplateParmDecl>(decl)) {
+            type = proto::SemanticTokenType::Type;
+        } else if(llvm::isa<clang::EnumDecl>(decl)) {
+            type = proto::SemanticTokenType::Enum;
+        } else if(llvm::isa<clang::EnumConstantDecl>(decl)) {
+            type = proto::SemanticTokenType::EnumMember;
+        } else if(auto TD = llvm::dyn_cast<clang::TagDecl>(decl)) {
+            type = TD->isStruct()  ? proto::SemanticTokenType::Struct
+                   : TD->isUnion() ? proto::SemanticTokenType::Union
+                                   : proto::SemanticTokenType::Class;
+        } else if(llvm::isa<clang::FieldDecl>(decl)) {
+            type = proto::SemanticTokenType::Field;
+        } else if(llvm::isa<clang::ParmVarDecl>(decl)) {
+            type = proto::SemanticTokenType::Parameter;
+        } else if(llvm::isa<clang::VarDecl, clang::BindingDecl, clang::NonTypeTemplateParmDecl>(
+                      decl)) {
+            type = proto::SemanticTokenType::Variable;
+        } else if(llvm::isa<clang::CXXMethodDecl>(decl)) {
+            type = proto::SemanticTokenType::Method;
+        } else if(llvm::isa<clang::FunctionDecl>(decl)) {
+            type = proto::SemanticTokenType::Function;
+        } else if(llvm::isa<clang::LabelDecl>(decl)) {
+            type = proto::SemanticTokenType::Label;
+        } else if(llvm::isa<clang::ConceptDecl>(decl)) {
+            type = proto::SemanticTokenType::Concept;
+        }
+
+        if(type != proto::SemanticTokenType::Invalid) {
+            addToken(location, type);
+        }
+    }
+
+    void handleOccurrence(const clang::BuiltinType* type,
+                          clang::SourceRange range,
+                          OccurrenceKind kind = OccurrenceKind::Source) {
+        // llvm::outs() << type->getName(clang::PrintingPolicy({})) << "\n";
+        // dump(range.getBegin());
+        // dump(range.getEnd());
+    }
+
+    void handleOccurrence(const clang::Attr* attr,
+                          clang::SourceRange range,
+                          OccurrenceKind kind = OccurrenceKind::Source) {
+        dump(range.getBegin());
+        auto tokens = tokBuf.expandedTokens(range);
+        if(auto first = tokens.begin()) {
+            auto second = first + 1;
+            switch(first->kind()) {
+                case clang::tok::identifier: {
+                    bool isFirstTokenNamespace = second && second->kind() == clang::tok::coloncolon;
+                    if(isFirstTokenNamespace) {
+                        addToken(first->location(), proto::SemanticTokenType::Namespace);
+                        first += 2;
+                    }
+
+                    assert(first && first->kind() == clang::tok::identifier &&
+                           "Expecting an identifier token");
+                    addToken(first->location(), proto::SemanticTokenType::Attribute);
+                    break;
+                }
+                /// [[using CC: opt(1), debug]]
+                case clang::tok::kw_using: {
+                    assert(second && second->kind() == clang::tok::identifier);
+                    addToken(second->location(), proto::SemanticTokenType::Namespace);
+                    break;
+                }
+                default: {
+                    std::terminate();
+                }
+            }
+        }
+    }
+
+    void run() {
+        TraverseAST(sema.getASTContext());
+    }
+
+    HighlightBuilder& addToken(clang::SourceLocation location, proto::SemanticTokenType type) {
+        auto loc = srcMgr.getPresumedLoc(location);
+        tokens.emplace_back(SemanticToken{
+            .line = loc.getLine() - 1,
+            .column = loc.getColumn() - 1,
+            .length = clang::Lexer::MeasureTokenLength(location, srcMgr, sema.getLangOpts()),
+            .type = type,
+            .modifiers = 0,
+        });
+        return *this;
+    }
+
+    proto::SemanticTokens build() {
+        TraverseAST(sema.getASTContext());
+
+        proto::SemanticTokens result;
+        std::ranges::sort(tokens, [](const SemanticToken& lhs, const SemanticToken& rhs) {
+            return lhs.line < rhs.line || (lhs.line == rhs.line && lhs.column < rhs.column);
+        });
+
+        std::size_t lastLine = 0;
+        std::size_t lastColumn = 0;
+
+        for(auto& token: tokens) {
+            result.data.push_back(token.line - lastLine);
+            result.data.push_back(token.line == lastLine ? token.column - lastColumn
+                                                         : token.column);
+            result.data.push_back(token.length);
+            result.data.push_back(llvm::to_underlying(token.type));
+            result.data.push_back(token.modifiers);
+
+            lastLine = token.line;
+            lastColumn = token.column;
+        }
+
+        return result;
+    }
+
+    std::vector<SemanticToken> tokens;
+};
+
 }  // namespace
 
+proto::SemanticTokens semanticTokens(Compiler& compiler, llvm::StringRef filename) {
+    HighlightBuilder builder(compiler);
+    return builder.build();
+}
+
 }  // namespace clice::feature
diff --git a/src/Server/Config.cpp b/src/Server/Config.cpp
index 2b3aad8b..bb191963 100644
--- a/src/Server/Config.cpp
+++ b/src/Server/Config.cpp
@@ -88,6 +88,7 @@ int parse(llvm::StringRef execute, llvm::StringRef filepath) {
             config.server.address = address.as_string()->get();
         }
 
+
         llvm::outs() << "Server:" << json::serialize(config.server) << "\n";
     }
     return 0;
diff --git a/src/Server/Server.cpp b/src/Server/Server.cpp
index 690b0053..2d272f1a 100644
--- a/src/Server/Server.cpp
+++ b/src/Server/Server.cpp
@@ -31,7 +31,7 @@ Server::Server() {
     addMethod("textDocument/codeLens", &Server::onCodeLens);
     addMethod("textDocument/foldingRange", &Server::onFoldingRange);
     addMethod("textDocument/documentSymbol", &Server::onDocumentSymbol);
-    addMethod("textDocument/semanticTokens", &Server::onSemanticTokens);
+    addMethod("textDocument/semanticTokens/full", &Server::onSemanticTokens);
     addMethod("textDocument/inlayHint", &Server::onInlayHint);
     addMethod("textDocument/completion", &Server::onCodeCompletion);
     addMethod("textDocument/signatureHelp", &Server::onSignatureHelp);
@@ -75,6 +75,7 @@ void Server::run(int argc, const char** argv) {
 }
 
 async::promise<void> Server::onInitialize(json::Value id, const proto::InitializeParams& params) {
+
     async::write(std::move(id), json::serialize(proto::InitializeResult()));
     co_return;
 }
@@ -203,7 +204,13 @@ async::promise<void> Server::onDocumentSymbol(json::Value id,
 
 async::promise<void> Server::onSemanticTokens(json::Value id,
                                               const proto::SemanticTokensParams& params) {
-
+    auto path = URI::resolve(params.textDocument.uri);
+    auto task = [this, id = std::move(id)](Compiler& compiler) -> async::promise<void> {
+        auto tokens = feature::semanticTokens(compiler, "");
+        async::write(std::move(id), json::serialize(tokens));
+        co_return;
+    };
+    co_await schedule(path, std::move(task));
     co_return;
 }
 
@@ -244,7 +251,9 @@ async::promise<void> Server::updatePCH(llvm::StringRef filepath,
     co_await async::schedule_task([&] {
         Compiler compiler(filepath, content, args);
         bounds = clang::Lexer::ComputePreamble(content, {}, false);
-        compiler.generatePCH(outpath, bounds.Size, bounds.PreambleEndsAtStartOfLine);
+        if(bounds.Size != 0) {
+            compiler.generatePCH(outpath, bounds.Size, bounds.PreambleEndsAtStartOfLine);
+        }
     });
     logger::info("Build PCH success");
 
@@ -260,7 +269,7 @@ async::promise<void> Server::updatePCH(llvm::StringRef filepath,
 async::promise<void> Server::buildAST(llvm::StringRef filepath, llvm::StringRef content) {
     llvm::SmallString<128> path = filepath;
 
-    /// FIXME: lookup from CDB file and adjust and remove unnecessary arguments.
+    /// FIXME: lookup from CDB file and adjust and remove unnecessary arguments.1
     llvm::SmallVector<const char*> args = {
         "clang++",
         "-std=c++20",
@@ -283,9 +292,10 @@ async::promise<void> Server::buildAST(llvm::StringRef filepath, llvm::StringRef
             boundSize -= 1;
             endAtStart = true;
         }
-
         std::unique_ptr<Compiler> compiler = std::make_unique<Compiler>(path, content, args);
-        compiler->applyPCH(pch.path, boundSize, endAtStart);
+        if(boundSize != 0) {
+            compiler->applyPCH(pch.path, boundSize, endAtStart);
+        }
         compiler->buildAST();
         return compiler;
     });
@@ -296,10 +306,23 @@ async::promise<void> Server::buildAST(llvm::StringRef filepath, llvm::StringRef
     unit.compiler = std::move(compiler);
 
     for(auto& task: unit.tasks) {
-        co_await task.request;
+        co_await task.request(*unit.compiler);
         if(task.kind == TranslationUnit::TaskKind::Build) {
             break;
         }
     }
 }
+
+async::promise<void>
+    Server::schedule(llvm::StringRef path,
+                     llvm::unique_function<async::promise<void>(Compiler&)> request) {
+    auto& unit = units[path];
+    if(unit.state == TranslationUnit::State::Building) {
+        unit.tasks.emplace_back(TranslationUnit::TaskKind::Consume, std::move(request));
+    } else {
+        co_await request(*units[path].compiler);
+    }
+
+    co_return;
+}
 }  // namespace clice
diff --git a/tests/ASTVisitor/macro.cpp b/tests/ASTVisitor/macro.cpp
index 86b3b6fd..24761444 100644
--- a/tests/ASTVisitor/macro.cpp
+++ b/tests/ASTVisitor/macro.cpp
@@ -12,3 +12,6 @@ int main() {
     struct name3 z;
 }
 
+#define Name(x) x
+
+int Name(x) = 1;
\ No newline at end of file
diff --git a/tests/ASTVisitor/test.cpp b/tests/ASTVisitor/test.cpp
index f43bfcc7..2e603ef0 100644
--- a/tests/ASTVisitor/test.cpp
+++ b/tests/ASTVisitor/test.cpp
@@ -1,16 +1,7 @@
-#include <type_traits>
+void foo [[gnu::format(printf, 1, 3)]] (const char* s, char* buf, ...);
 
-template <typename T>
-std::enable_if_t<!std::is_same_v<T, int>, int> foo() {}
+void __attribute__((__format__(printf, 1, 3))) bar(const char* s, char* buf, ...);
 
-template <typename T>
-std::enable_if_t<!std::is_same_v<T, double>, int> foo() {}
-
-int foo();
-
-int main() {
-    foo();
-    foo<int>();
-    foo<double>();
-    return 0;
+void foo2(int x) {
+    if(x < 3) [[unlikely]] {}
 }
diff --git a/unittests/AST/ASTVisitor.cpp b/unittests/AST/ASTVisitor.cpp
index cf77f4d2..69eb95d7 100644
--- a/unittests/AST/ASTVisitor.cpp
+++ b/unittests/AST/ASTVisitor.cpp
@@ -6,6 +6,7 @@
 #include "../Test.h"
 #include "clang/AST/DeclTemplate.h"
 #include "Compiler/Semantic.h"
+#include "Feature/SemanticTokens.h"
 
 namespace {
 
@@ -48,16 +49,38 @@ public:
         }
     }
 
-    // bool VisitTemplateSpecializationTypeLoc(clang::TemplateSpecializationTypeLoc loc) {
-    //     loc.dump();
-    //     return true;
-    // }
+    bool VisitUnresolvedLookupExpr(clang::UnresolvedLookupExpr* expr) {
+        if(srcMgr.isInMainFile(expr->getNameLoc())) {
+            expr->dump();
+        }
+        return true;
+    }
+
+    bool VisitTemplateSpecializationTypeLoc(clang::TemplateSpecializationTypeLoc loc) {
+        if(srcMgr.isInMainFile(loc.getLAngleLoc())) {
+            loc.dump();
+        }
+        return true;
+    }
 
     bool VisitDependentScopeDeclRefExpr(clang::DependentScopeDeclRefExpr* expr) {
         expr->dump();
         for(auto member: compiler.resolver().lookup(expr)) {
             member->dump();
         }
+        clang::UserDefinedLiteral* literal;
+        auto x = "x\n";
+        return true;
+    }
+
+    bool VisitParmVarDecl(clang::ParmVarDecl* decl) {
+        // decl->getTypeSourceInfo()->getTypeLoc().dump();
+        return true;
+    }
+
+    bool VisitTypeLoc(clang::TypeLoc loc) {
+        loc.dump();
+        loc.getBeginLoc().dump(srcMgr);
         return true;
     }
 };
@@ -67,19 +90,49 @@ TEST(clice, ASTVisitor) {
         if(filepath.ends_with("test.cpp")) {
             std::vector<const char*> compileArgs = {
                 "clang++",
-                "-std=c++20",
+                "-std=c++23",
                 filepath.c_str(),
                 "-resource-dir",
                 "/home/ykiko/C++/clice2/build/lib/clang/20",
             };
-            Compiler compiler(compileArgs);
-            compiler.buildAST();
 
-            SemanticVisitor visitor(compiler);
-            visitor.TraverseAST(compiler.context());
+            auto bounds = clang::Lexer::ComputePreamble(content, {}, false);
+            // auto start1 = std::chrono::steady_clock::now();
+            //{
+            //     Compiler compiler(filepath, content, compileArgs);
+            //     compiler.generatePCH("/home/ykiko/C++/clice2/build/cache/xxx.pch",
+            //                          bounds.Size,
+            //                          bounds.PreambleEndsAtStartOfLine);
+            // }
+            // auto end1 = std::chrono::steady_clock::now();
+
+            auto start2 = std::chrono::steady_clock::now();
+            Compiler compiler(compileArgs);
+            // compiler.applyPCH("/home/ykiko/C++/clice2/build/cache/xxx.pch",
+            //                   bounds.Size,
+            //                   bounds.PreambleEndsAtStartOfLine);
+            compiler.buildAST();
+            auto end2 = std::chrono::steady_clock::now();
+
             // ASTVisitor visitor(compiler, compiler.srcMgr(), compiler.sema());
-            // visitor.TraverseAST(compiler.context());
-            //  compiler.tu()->dump();
+            // visitor.TraverseAST(compiler.sema().getASTContext());
+
+            auto start3 = std::chrono::steady_clock::now();
+            auto r = feature::semanticTokens(compiler, filepath);
+            auto end3 = std::chrono::steady_clock::now();
+
+            // llvm::outs()
+            //     << "Build PCH: "
+            //     << std::chrono::duration_cast<std::chrono::milliseconds>(end1 - start1).count()
+            //     << "ms\n";
+            llvm::outs()
+                << "Build AST: "
+                << std::chrono::duration_cast<std::chrono::milliseconds>(end2 - start2).count()
+                << "ms\n";
+            llvm::outs()
+                << "Semantic Tokens: "
+                << std::chrono::duration_cast<std::chrono::milliseconds>(end3 - start3).count()
+                << "ms\n";
         }
     });
 }