Some update.

Author: 16bit-ykiko

include/Compiler/Compilation.h

@@ -12,6 +12,9 @@ class CodeCompleteConsumer;
 namespace clice {
 
 struct CompilationParams {
+    /// The kind of this compilation.
+    CompilationUnit::Kind kind;
+
     /// Output file path.
     llvm::SmallString<128> output_file;
 

include/Compiler/CompilationUnit.h

@@ -28,9 +28,9 @@ class CompilationUnit {
         /// From building precompiled module for the module interface unit.
         ModuleInterface,
 
-        /// From building normal AST for source file, interested file and top level
+        /// From building normal AST for source file(except preamble), interested file and top level
         /// declarations are available.
-        SyntaxOnly,
+        Content,
 
         /// From running code completion for the source file(preamble is applied).
         Completion,

src/Compiler/Compilation.cpp

@@ -66,31 +66,27 @@ class ProxyASTConsumer final : public clang::MultiplexConsumer {
 class ProxyAction final : public clang::WrapperFrontendAction {
 public:
     ProxyAction(std::unique_ptr<clang::FrontendAction> action,
-                bool collect_top_level_decls,
+                std::vector<clang::Decl*>* top_level_decls,
                 std::shared_ptr<std::atomic_bool> stop) :
-        clang::WrapperFrontendAction(std::move(action)), need_collect(collect_top_level_decls),
+        clang::WrapperFrontendAction(std::move(action)), top_level_decls(top_level_decls),
         stop(std::move(stop)) {}
 
     auto CreateASTConsumer(clang::CompilerInstance& instance, llvm::StringRef file)
         -> std::unique_ptr<clang::ASTConsumer> final {
         return std::make_unique<ProxyASTConsumer>(
             WrapperFrontendAction::CreateASTConsumer(instance, file),
             instance,
-            need_collect ? &top_level_decls : nullptr,
+            top_level_decls,
             std::move(stop));
     }
 
     /// Make this public.
     using clang::WrapperFrontendAction::EndSourceFile;
 
-    auto pop_decls() {
-        return std::move(top_level_decls);
-    }
-
 private:
     /// Whether we need to collect top level declarations.
     bool need_collect;
-    std::vector<clang::Decl*> top_level_decls;
+    std::vector<clang::Decl*>* top_level_decls;
     std::shared_ptr<std::atomic_bool> stop;
 };
 
@@ -149,14 +145,15 @@ auto create_invocation(CompilationParams& params,
 }
 
 /// Do nothing before or after compile state.
-constexpr static auto NoHook = [](auto& /*ignore*/) {
+constexpr static auto no_hook = [](auto& /*ignore*/) {
 };
 
-template <typename Action>
+template <typename Action,
+          typename BeforeExecute = decltype(no_hook),
+          typename AfterExecute = decltype(no_hook)>
 CompilationResult run_clang(CompilationParams& params,
-                            auto before_execute = NoHook,
-                            auto after_execute = NoHook,
-                            bool collect = false) {
+                            const BeforeExecute& before_execute = no_hook,
+                            const AfterExecute& after_execute = no_hook) {
     auto diagnostics =
         params.diagnostics ? params.diagnostics : std::make_shared<std::vector<Diagnostic>>();
     auto diagnostic_engine =
@@ -186,7 +183,17 @@ CompilationResult run_clang(CompilationParams& params,
     /// Adjust the compiler instance, for example, set preamble or modules.
     before_execute(*instance);
 
-    auto action = std::make_unique<ProxyAction>(std::make_unique<Action>(), collect, params.stop);
+    /// Frontend information ...
+    std::vector<clang::Decl*> top_level_decls;
+    llvm::DenseMap<clang::FileID, Directive> directives;
+    std::optional<clang::syntax::TokenCollector> token_collector;
+
+    auto action = std::make_unique<ProxyAction>(
+        std::make_unique<Action>(),
+        /// We only collect top level declarations for parse main file.
+        params.kind == CompilationUnit::Content ? &top_level_decls : nullptr,
+        params.stop);
+
     if(!action->BeginSourceFile(*instance, instance->getFrontendOpts().Inputs[0])) {
         return std::unexpected("Fail to begin source file");
     }
@@ -196,18 +203,12 @@ CompilationResult run_clang(CompilationParams& params,
 
     /// `BeginSourceFile` may create new preprocessor, so all operations related to preprocessor
     /// should be done after `BeginSourceFile`.
-
-    /// Collect directives.
-    llvm::DenseMap<clang::FileID, Directive> directives;
     Directive::attach(pp, directives);
 
-    /// Collect tokens.
-    std::optional<clang::syntax::TokenCollector> tok_collector;
-
     /// It is not necessary to collect tokens if we are running code completion.
     /// And in fact will cause assertion failure.
     if(!instance->hasCodeCompletionConsumer()) {
-        tok_collector.emplace(pp);
+        token_collector.emplace(pp);
     }
 
     if(auto error = action->Execute()) {
@@ -231,9 +232,9 @@ CompilationResult run_clang(CompilationParams& params,
         return std::unexpected("Compilation is canceled.");
     }
 
-    std::optional<clang::syntax::TokenBuffer> tok_buf;
-    if(tok_collector) {
-        tok_buf = std::move(*tok_collector).consume();
+    std::optional<clang::syntax::TokenBuffer> token_buffer;
+    if(token_collector) {
+        token_buffer = std::move(*token_collector).consume();
     }
 
     /// FIXME: getDependencies currently return ArrayRef<std::string>, which actually results in
@@ -244,38 +245,34 @@ CompilationResult run_clang(CompilationParams& params,
         resolver.emplace(instance->getSema());
     }
 
-    auto top_level_decls = action->pop_decls();
-
     auto impl = new CompilationUnit::Impl{
         .interested = pp.getSourceManager().getMainFileID(),
         .src_mgr = instance->getSourceManager(),
         .action = std::move(action),
         .instance = std::move(instance),
         .m_resolver = std::move(resolver),
-        .buffer = std::move(tok_buf),
+        .buffer = std::move(token_buffer),
         .m_directives = std::move(directives),
         .pathCache = llvm::DenseMap<clang::FileID, llvm::StringRef>(),
         .symbolHashCache = llvm::DenseMap<const void*, std::uint64_t>(),
         .diagnostics = diagnostics,
         .top_level_decls = std::move(top_level_decls),
     };
 
-    CompilationUnit unit(CompilationUnit::SyntaxOnly, impl);
+    CompilationUnit unit(CompilationUnit::Content, impl);
     after_execute(unit);
     return unit;
 }
 
 }  // namespace
 
 CompilationResult preprocess(CompilationParams& params) {
-    return run_clang<clang::PreprocessOnlyAction>(params,
-                                                  /*before_execute=*/NoHook,
-                                                  /*after_execute=*/NoHook);
+    return run_clang<clang::PreprocessOnlyAction>(params);
 }
 
 CompilationResult compile(CompilationParams& params) {
     const bool collect_top_level_decls = params.output_file.empty();
-    return run_clang<clang::SyntaxOnlyAction>(params, NoHook, NoHook, collect_top_level_decls);
+    return run_clang<clang::SyntaxOnlyAction>(params);
 }
 
 CompilationResult compile(CompilationParams& params, PCHInfo& out) {
@@ -304,8 +301,7 @@ CompilationResult compile(CompilationParams& params, PCHInfo& out) {
             out.preamble = unit.interested_content();
             out.deps = unit.deps();
             out.arguments = params.arguments;
-        },
-        /*collect_top_level_decls=*/true);
+        });
 }
 
 CompilationResult compile(CompilationParams& params, PCMInfo& out) {
@@ -327,8 +323,7 @@ CompilationResult compile(CompilationParams& params, PCMInfo& out) {
             for(auto& [name, path]: params.pcms) {
                 out.mods.emplace_back(name);
             }
-        },
-        /*collect_top_level_decls=*/true);
+        });
 }
 
 CompilationResult complete(CompilationParams& params, clang::CodeCompleteConsumer* consumer) {
@@ -351,16 +346,13 @@ CompilationResult complete(CompilationParams& params, clang::CodeCompleteConsume
         column += 1;
     }
 
-    return run_clang<clang::SyntaxOnlyAction>(
-        params,
-        [&](clang::CompilerInstance& instance) {
-            /// Set options to run code completion.
-            instance.getFrontendOpts().CodeCompletionAt.FileName = std::move(file);
-            instance.getFrontendOpts().CodeCompletionAt.Line = line;
-            instance.getFrontendOpts().CodeCompletionAt.Column = column;
-            instance.setCodeCompletionConsumer(consumer);
-        },
-        /*after_execute=*/NoHook);
+    return run_clang<clang::SyntaxOnlyAction>(params, [&](clang::CompilerInstance& instance) {
+        /// Set options to run code completion.
+        instance.getFrontendOpts().CodeCompletionAt.FileName = std::move(file);
+        instance.getFrontendOpts().CodeCompletionAt.Line = line;
+        instance.getFrontendOpts().CodeCompletionAt.Column = column;
+        instance.setCodeCompletionConsumer(consumer);
+    });
 }
 
 }  // namespace clice

src/Server/Document.cpp

@@ -183,6 +183,7 @@ async::Task<bool> build_pch_task(CompilationDatabase::LookupInfo& info,
     diagnostics->clear();
 
     CompilationParams params;
+    params.kind = CompilationUnit::Preamble;
     params.output_file = path::join(config::cache.dir, path::filename(path) + ".pch");
     params.arguments = std::move(info.arguments);
     params.diagnostics = diagnostics;
@@ -294,6 +295,7 @@ async::Task<> Server::build_ast(std::string path, std::string content) {
     }
 
     CompilationParams params;
+    params.kind = CompilationUnit::Content;
     params.arguments = database.get_command(path, true, true).arguments;
     params.add_remapped_file(path, content);
     params.pch = {pch->path, pch->preamble.size()};

src/Server/Feature.cpp

@@ -24,6 +24,7 @@ async::Task<json::Value> Server::on_completion(proto::CompletionParams params) {
     {
         /// Set compilation params ... .
         CompilationParams params;
+        params.kind = CompilationUnit::Completion;
         params.arguments = database.get_command(path, true).arguments;
         params.add_remapped_file(path, content);
         params.pch = {pch->path, pch->preamble.size()};