Reland folding range (#94)

Author: 16bit-ykiko

include/Basic/SourceCode.h

@@ -8,10 +8,10 @@ namespace clice {
 
 struct LocalSourceRange {
     /// The begin position offset to the source file.
-    uint32_t begin;
+    uint32_t begin = -1;
 
     /// The end position offset to the source file.
-    uint32_t end;
+    uint32_t end = -1;
 
     constexpr bool operator== (const LocalSourceRange& other) const = default;
 

include/Compiler/Directive.h

@@ -119,7 +119,7 @@ struct Pragma {
     /// Kind of the pragma.
     Kind kind;
 
-    /// Location of the pragma token.
+    /// Location of the `#` token.
     clang::SourceLocation loc;
 };
 

include/Feature/FoldingRange.h

@@ -1,90 +1,59 @@
-#include "Basic/Document.h"
+#pragma once
+
 #include "Basic/SourceCode.h"
 #include "Index/Shared.h"
-#include "Support/JSON.h"
+#include "Support/Enum.h"
 
 namespace clice {
 
-namespace proto {
-
-/// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#foldingRangeClientCapabilities
-struct FoldingRangeClientCapabilities {};
+class ASTInfo;
 
-/// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#foldingRangeParams
-struct FoldingRangeParams {
-    /// The text document.
-    TextDocumentIdentifier textDocument;
-};
+namespace feature {
 
 struct FoldingRangeKind : refl::Enum<FoldingRangeKind> {
     enum Kind : uint8_t {
         Invalid = 0,
         Comment,
         Imports,
         Region,
+        Namespace,
+        Class,
+        Enum,
+        Struct,
+        Union,
+        LambdaCapture,
+        FunctionParams,
+        FunctionBody,
+        FunctionCall,
+        CompoundStmt,
+        AccessSpecifier,
+        ConditionDirective,
+        Initializer,
     };
 
     using Enum::Enum;
 
     constexpr static auto InvalidEnum = Invalid;
 };
 
-/// https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#foldingRange
+/// We don't record the coalesced text for a range, because it's rarely useful.
 struct FoldingRange {
-    /// The zero-based start line of the range to fold. The folded area starts after the line's last
-    /// character.
-    uinteger startLine;
-
-    /// The zero-based end line of the range to fold. The folded area ends with the line's last
-    /// character.
-    uinteger endLine;
-
-    /// The zero-based character offset from where the folded range starts.
-    uinteger startCharacter;
-
-    /// The zero-based character offset before the folded range ends.
-    uinteger endCharacter;
+    /// The range to fold.
+    LocalSourceRange range;
 
     /// Describes the kind of the folding range.
     FoldingRangeKind kind;
 
-    // The text that the client should show when the specified range is collapsed.
-    string collapsedText;
+    /// The text to display when the folding range is collapsed.
+    std::string text;
 };
 
-using FoldingRangeResult = std::vector<FoldingRange>;
-
-}  // namespace proto
-
-class ASTInfo;
-class SourceConverter;
-
-namespace feature::foldingrange {
-
-json::Value capability(json::Value clientCapabilities);
-
-/// We don't record the coalesced text for a range, because it's rarely useful.
-struct FoldingRange {
-    LocalSourceRange range;
-    proto::FoldingRangeKind kind;
-};
-
-using Result = std::vector<FoldingRange>;
+/// Generate folding range for interested file only.
+std::vector<FoldingRange> foldingRange(ASTInfo& AST);
 
 /// Generate folding range for all files.
-index::Shared<Result> foldingRange(ASTInfo& AST);
-
-/// Return folding range in main file.
-Result foldingRange(proto::FoldingRangeParams param, ASTInfo& AST);
-
-proto::FoldingRange toLspType(const FoldingRange& folding,
-                              const SourceConverter& SC,
-                              llvm::StringRef content);
-
-proto::FoldingRangeResult toLspResult(llvm::ArrayRef<FoldingRange> foldings,
-                                      const SourceConverter& SC,
-                                      llvm::StringRef content);
+index::Shared<std::vector<FoldingRange>> indexFoldingRange(ASTInfo& AST);
 
-}  // namespace feature::foldingrange
+}  // namespace feature
 
 }  // namespace clice

include/Index/FeatureIndex.h

@@ -4,6 +4,7 @@
 
 #include "Shared.h"
 #include "Feature/SemanticTokens.h"
+#include "Feature/FoldingRange.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "clang/Basic/SourceLocation.h"

include/Server/LSPConverter.h

@@ -17,6 +17,8 @@ class LSPConverter {
 
     Result convert(llvm::StringRef path, llvm::ArrayRef<feature::SemanticToken> tokens);
 
+    Result convert(llvm::StringRef path, llvm::ArrayRef<feature::FoldingRange> foldings);
+
     Result convert(const feature::Hover& hover);
 
 private:

include/Support/JSON.h

@@ -343,6 +343,12 @@ struct Serde<E> {
     }
 };
 
+template <typename T>
+constexpr inline bool is_optional_v = false;
+
+template <typename T>
+constexpr inline bool is_optional_v<std::optional<T>> = true;
+
 template <refl::reflectable_struct T>
 struct Serde<T> {
     constexpr inline static bool stateful =
@@ -351,9 +357,16 @@ struct Serde<T> {
     template <typename... Serdes>
     static json::Value serialize(const T& t, Serdes&&... serdes) {
         json::Object object;
-        refl::foreach(t, [&](std::string_view name, auto& member) {
-            object.try_emplace(llvm::StringRef(name),
-                               json::serialize(member, std::forward<Serdes>(serdes)...));
+        refl::foreach(t, [&]<typename Field>(std::string_view name, const Field& field) {
+            if constexpr(is_optional_v<Field>) {
+                if(field) {
+                    object.try_emplace(llvm::StringRef(name),
+                                       json::serialize(*field, std::forward<Serdes>(serdes)...));
+                }
+            } else {
+                object.try_emplace(llvm::StringRef(name),
+                                   json::serialize(field, std::forward<Serdes>(serdes)...));
+            }
         });
         return object;
     }

include/Support/Struct.h

@@ -12,10 +12,10 @@ namespace clice::refl {
 namespace impl {
 
 struct Any {
-    consteval Any(std::size_t);
+    constexpr Any(std::size_t);
 
     template <typename T>
-    consteval operator T () const;
+    constexpr operator T () const;
 };
 
 template <typename T, std::size_t N>