Clean Server (#93)

Author: 16bit-ykiko

docs/configuration.md

@@ -177,3 +177,41 @@ If `index.instantiation` is `true`, clice will traverse declarations in template
 
 If `index.instantiation` is `false`, clice will not index entities inside template instantiations, and `go-to-definition` will return no results.
 <br>
+
+## Feature
+
+### Semantic Tokens
+
+| Name                                 | Type               | Default |
+| ------------------------------------ | ------------------ | ------- |
+| `feature.semanticTokens.typeMap`     | `array` of `table` | `[]`    |
+| `feature.semanticTokens.modifierMap` | `array` of `table` | `[]`    |
+
+Maps the customized semantic symbol kinds or modifier to LSP semantic token types or modifiers.
+
+Example:
+
+```toml
+[feature.semanticTokens]
+typeMap = [
+    {"from": "header", "to": "string"},
+    {"from": "attribute", "to": "decorator"},
+]
+
+modifierMap = [
+    {"from": "const", "to": "readonly"},
+    {"from": "pureVirtual", "to": "abstract"},
+]
+```
+
+For all clice symbol kinds, please refer to [SymbolKind](https://github.com/clice-project/clice/blob/main/include/AST/SymbolKind.h). The first letter of the name should be translated to lowercase. For all LSP semantic token types, refer to [SemanticTokenKind](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens).
+
+
+| Name                              | Type      | Default |
+| --------------------------------- | --------- | ------- |
+| `feature.semanticTokens.standard` | `boolean` | `false` |
+
+If `true`, clice will map the semantic token types and modifiers to the standard ones automatically.
+
+### Folding Range
+

include/Basic/Lifecycle.h

@@ -78,6 +78,59 @@ struct SemanticTokensOptions {
     bool full = true;
 };
 
+struct SemanticTokens {
+    /// The actual tokens.
+    std::vector<std::uint32_t> data;
+};
+
+/// A set of predefined range kinds.
+enum class FoldingRangeKind {
+    /// Folding range for a comment.
+    Comment,
+
+    /// Folding range for imports or includes.
+    Imports,
+
+    /// Folding range for a region.
+    Region,
+};
+
+/// Represents a folding range. To be valid, start and end line must be bigger
+/// than zero and smaller than the number of lines in the document. Clients
+/// are free to ignore invalid ranges.
+struct FoldingRange {
+    /// The zero-based start line of the range to fold. The folded area starts
+    /// after the line's last character. To be valid, the end must be zero or
+    /// larger and smaller than the number of lines in the document.
+    uint32_t startLine;
+
+    /// The zero-based character offset from where the folded range starts. If
+    /// not defined, defaults to the length of the start line.
+    std::optional<uint32_t> startCharacter;
+
+    /// The zero-based end line of the range to fold. The folded area ends with
+    /// the line's last character. To be valid, the end must be zero or larger
+    /// and smaller than the number of lines in the document.
+    uint32_t endLine;
+
+    /// The zero-based character offset before the folded range ends. If not
+    /// defined, defaults to the length of the end line.
+    std::optional<uint32_t> endCharacter;
+
+    /// Describes the kind of the folding range such as `comment` or `region`.
+    /// The kind is used to categorize folding ranges and used by commands like
+    /// 'Fold all comments'. See [FoldingRangeKind](#FoldingRangeKind) for an
+    /// enumeration of standardized kinds.
+    FoldingRangeKind kind;
+
+    /// The text that the client should show when the specified range is
+    /// collapsed. If not defined or not supported by the client, a default
+    /// will be chosen by the client.
+    ///
+    /// @since 3.17.0 - proposed
+    std::optional<std::string> collapsedText;
+};
+
 /// Server Capability.
 struct ServerCapabilities {
     /// The position encoding the server picked from the encodings offered
@@ -118,6 +171,9 @@ struct ServerCapabilities {
 
     /// The server provides semantic tokens support.
     SemanticTokensOptions semanticTokensProvider;
+
+    /// The server provides folding provider support.
+    bool foldingRangeProvider = true;
 };
 
 struct InitializeResult {

include/Compiler/Command.h

@@ -1,8 +1,7 @@
 #pragma once
 
 #include <expected>
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
 
 namespace clice {
 
@@ -18,4 +17,50 @@ std::expected<void, std::string> mangleCommand(llvm::StringRef command,
                                                llvm::SmallVectorImpl<const char*>& out,
                                                llvm::SmallVectorImpl<char>& buffer);
 
+/// `CompilationDatabase` is responsible for managing the compile commands.
+///
+/// FIXME: currently we assume that a file only occurs once in the CDB.
+/// This is not always correct, but it is enough for now.
+class CompilationDatabase {
+public:
+    /// Update the compile commands with the given file.
+    void updateCommands(llvm::StringRef file);
+
+    /// Update the compile commands with the given file and compile command.
+    void updateCommand(llvm::StringRef file, llvm::StringRef command);
+
+    /// Update the module map with the given file and module name.
+    void updateModule(llvm::StringRef file, llvm::StringRef name);
+
+    /// Lookup the compile commands of the given file.
+    llvm::StringRef getCommand(llvm::StringRef file);
+
+    /// Lookup the module interface unit file path of the given module name.
+    llvm::StringRef getModuleFile(llvm::StringRef name);
+
+    auto size() const {
+        return commands.size();
+    }
+
+    auto begin() {
+        return commands.begin();
+    }
+
+    auto end() {
+        return commands.end();
+    }
+
+private:
+    /// A map between file path and compile commands.
+    llvm::StringMap<std::string> commands;
+
+    /// For C++20 module, we only can got dependent module name
+    /// in source context. But we need dependent module file path
+    /// to build PCM. So we will scan(preprocess) all project files
+    /// to build a module map between module name and module file path.
+    /// **Note that** this only includes module interface unit, for module
+    /// implementation unit, the scan could be delayed until compiling it.
+    llvm::StringMap<std::string> moduleMap;
+};
+
 }  // namespace clice

include/Feature/DocumentSymbol.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "Basic/Document.h"
 #include "Basic/SourceCode.h"
 #include "Index/Shared.h"

include/Index/FeatureIndex.h

@@ -31,7 +31,9 @@ class FeatureIndex {
         }
     }
 
-    llvm::ArrayRef<feature::SemanticToken> semanticTokens() const;
+    std::vector<feature::SemanticToken> semanticTokens() const;
+
+    std::vector<feature::FoldingRange> foldingRanges() const;
 
 public:
     char* base;

include/Index/Shared2.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "SymbolIndex.h"
+#include "FeatureIndex.h"
+#include "Async/FileSystem.h"
+
+namespace clice::index {
+
+struct Index2 {
+    std::optional<SymbolIndex> symbol;
+    llvm::XXH128_hash_t symbolHash = {0, 0};
+
+    std::optional<FeatureIndex> feature;
+    llvm::XXH128_hash_t featureHash = {0, 0};
+
+    static Shared<Index2> build(ASTInfo& AST);
+
+    async::Task<> write(std::string path) {
+        if(symbol) {
+            co_await async::fs::write(path + ".sidx", symbol->base, symbol->size);
+        }
+
+        if(feature) {
+            co_await async::fs::write(path + ".fidx", feature->base, feature->size);
+        }
+    }
+};
+
+}  // namespace clice::index

include/Server/Cache.h

@@ -1,14 +1,15 @@
 #pragma once
 
 #include <vector>
+#include <expected>
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace clice::config {
 
 /// Read the config file, call when the program starts.
-void load(llvm::StringRef execute, llvm::StringRef filename);
+std::expected<void, std::string> load(llvm::StringRef execute, llvm::StringRef filename);
 
 /// Initialize the config, replace all predefined variables in the config file.
 /// called in `Server::initialize`.