Merge branch 'main' of https://github.com/clice-project/clice into pr/Guo-Shiyu/184-1

Author: 16bit-ykiko

include/AST/SourceCode.h

@@ -46,6 +46,10 @@ struct LocalSourceRange {
 
     constexpr bool operator== (const LocalSourceRange& other) const = default;
 
+    constexpr auto length() {
+        return end - begin;
+    }
+
     constexpr bool contains(uint32_t offset) const {
         return offset >= begin && offset <= end;
     }

include/AST/Utility.h

@@ -12,71 +12,58 @@ bool is_definition(const clang::Decl* decl);
 /// we consider it as a template while clang does not.
 bool is_templated(const clang::Decl* decl);
 
+/// Check whether the decl is anonymous.
+bool is_anonymous(const clang::NamedDecl* decl);
+
 /// Return the decl where it is instantiated from. If could be a template decl
 /// or a member of a class template. If the decl is a full specialization, return
 /// itself.
 const clang::NamedDecl* instantiated_from(const clang::NamedDecl* decl);
 
 const clang::NamedDecl* normalize(const clang::NamedDecl* decl);
 
+llvm::StringRef identifier_of(const clang::NamedDecl& D);
+
+llvm::StringRef identifier_of(clang::QualType T);
+
 /// Get the name of the decl.
 std::string name_of(const clang::NamedDecl* decl);
 
+std::string display_name_of(const clang::NamedDecl* decl);
+
 /// To response go-to-type-definition request. Some decls actually have a type
 /// for example the result of `typeof(var)` is the type of `var`. This function
 /// returns the type for the decl if any.
 clang::QualType type_of(const clang::NamedDecl* decl);
 
-const clang::NamedDecl* get_decl_for_type(const clang::Type* T);
-
 /// Get the underlying decl for a type if any.
-const clang::NamedDecl* decl_of(clang::QualType type);
-
-/// Check whether the decl is anonymous.
-bool is_anonymous(const clang::NamedDecl* decl);
-
-clang::NestedNameSpecifierLoc get_qualifier_loc(const clang::NamedDecl* decl);
-
-auto get_template_specialization_args(const clang::NamedDecl* decl)
-    -> std::optional<llvm::ArrayRef<clang::TemplateArgumentLoc>>;
+auto decl_of(clang::QualType type) -> const clang::NamedDecl*;
 
-std::string print_template_specialization_args(const clang::NamedDecl* decl);
+/// Recursively strips all pointers, references, and array extents from
+/// a TypeLoc. e.g., for "const int*(&)[3]", the result will be location
+/// "for int".
+auto unwrap_type(clang::TypeLoc type, bool unwrap_function_type = true) -> clang::TypeLoc;
 
-std::string print_name(const clang::NamedDecl* decl);
+auto get_only_instantiation(clang::NamedDecl* templated_decl) -> clang::NamedDecl*;
 
-clang::TemplateTypeParmTypeLoc get_contained_auto_param_type(clang::TypeLoc TL);
+auto get_only_instantiation(clang::ParmVarDecl* param) -> clang::ParmVarDecl*;
 
-clang::NamedDecl* get_only_instantiation(clang::NamedDecl* TemplatedDecl);
-
-/// getSimpleName() returns the plain identifier for an entity, if any.
-llvm::StringRef getSimpleName(const clang::DeclarationName& DN);
-llvm::StringRef getSimpleName(const clang::NamedDecl& D);
-llvm::StringRef getSimpleName(clang::QualType T);
-
-std::string summarizeExpr(const clang::Expr* E);
-
-// Returns the template parameter pack type from an instantiated function
-// template, if it exists, nullptr otherwise.
-const clang::TemplateTypeParmType* getFunctionPackType(const clang::FunctionDecl* Callee);
+std::string summarize_expr(const clang::Expr* E);
 
 // Returns the template parameter pack type that this parameter was expanded
 // from (if in the Args... or Args&... or Args&&... form), if this is the case,
 // nullptr otherwise.
-const clang::TemplateTypeParmType* getUnderlyingPackType(const clang::ParmVarDecl* Param);
+const clang::TemplateTypeParmType* underlying_pack_type(const clang::ParmVarDecl* param);
 
 // Returns the parameters that are forwarded from the template parameters.
 // For example, `template <typename... Args> void foo(Args... args)` will return
 // the `args` parameters.
-llvm::SmallVector<const clang::ParmVarDecl*>
-    resolveForwardingParameters(const clang::FunctionDecl* D, unsigned MaxDepth = 10);
-
-// Determines if any intermediate type in desugaring QualType QT is of
-// substituted template parameter type. Ignore pointer or reference wrappers.
-bool isSugaredTemplateParameter(clang::QualType QT);
+auto resolve_forwarding_params(const clang::FunctionDecl* decl, unsigned max_depth = 10)
+    -> llvm::SmallVector<const clang::ParmVarDecl*>;
 
 // A simple wrapper for `clang::desugarForDiagnostic` that provides optional
 // semantic.
-std::optional<clang::QualType> desugar(clang::ASTContext& AST, clang::QualType QT);
+std::optional<clang::QualType> desugar(clang::ASTContext& context, clang::QualType type);
 
 // Apply a series of heuristic methods to determine whether or not a QualType QT
 // is suitable for desugaring (e.g. getting the real name behind the using-alias
@@ -85,12 +72,12 @@ std::optional<clang::QualType> desugar(clang::ASTContext& AST, clang::QualType Q
 //
 // This could be refined further. See
 // https://github.com/clangd/clangd/issues/1298.
-clang::QualType maybeDesugar(clang::ASTContext& AST, clang::QualType QT);
+clang::QualType maybe_desugar(clang::ASTContext& context, clang::QualType type);
 
 // Given a callee expression `Fn`, if the call is through a function pointer,
 // try to find the declaration of the corresponding function pointer type,
 // so that we can recover argument names from it.
 // FIXME: This function is mostly duplicated in SemaCodeComplete.cpp; unify.
-clang::FunctionProtoTypeLoc getPrototypeLoc(clang::Expr* Fn);
+clang::FunctionProtoTypeLoc proto_type_loc(clang::Expr* expr);
 
 }  // namespace clice::ast

include/Async/Task.h

@@ -317,10 +317,10 @@ class Task {
     void stacktrace() {
         promise_base* handle = core;
         while(handle) {
-            clice::println("{}:{}:{}",
-                           handle->location.file_name(),
-                           handle->location.line(),
-                           handle->location.function_name());
+            std::println("{}:{}:{}",
+                         handle->location.file_name(),
+                         handle->location.line(),
+                         handle->location.function_name());
             handle = handle->continuation;
         }
     }

include/Compiler/CompilationUnit.h

@@ -122,21 +122,32 @@ class CompilationUnit {
     /// Create a file location with given file id and offset.
     auto create_location(clang::FileID fid, std::uint32_t offset) -> clang::SourceLocation;
 
+    using TokenRange = llvm::ArrayRef<clang::syntax::Token>;
+
     /// Get the spelled tokens(raw token) of the file id.
-    auto spelled_tokens(clang::FileID fid) -> llvm::ArrayRef<clang::syntax::Token>;
+    auto spelled_tokens(clang::FileID fid) -> TokenRange;
+
+    /// Return the spelled tokens corresponding to the range.
+    auto spelled_tokens(clang::SourceRange range) -> TokenRange;
 
     /// The spelled tokens that overlap or touch a spelling location Loc.
     /// This always returns 0-2 tokens.
-    auto spelled_tokens_touch(clang::SourceLocation location)
-        -> llvm::ArrayRef<clang::syntax::Token>;
-
-    auto expanded_tokens() -> llvm::ArrayRef<clang::syntax::Token>;
-
-    /// Get the expanded tokens(after preprocessing) of the file id.
-    auto expanded_tokens(clang::SourceRange range) -> llvm::ArrayRef<clang::syntax::Token>;
-
-    auto expansions_overlapping(llvm::ArrayRef<clang::syntax::Token>)
-        -> std::vector<clang::syntax::TokenBuffer::Expansion>;
+    auto spelled_tokens_touch(clang::SourceLocation location) -> TokenRange;
+
+    /// All tokens produced by the preprocessor after all macro replacements,
+    /// directives, etc. Source locations found in the clang AST will always
+    /// point to one of these tokens.
+    /// Tokens are in TU order (per SourceManager::isBeforeInTranslationUnit()).
+    /// FIXME: figure out how to handle token splitting, e.g. '>>' can be split
+    ///        into two '>' tokens by the parser. However, TokenBuffer currently
+    ///        keeps it as a single '>>' token.
+    auto expanded_tokens() -> TokenRange;
+
+    /// Returns the subrange of expandedTokens() corresponding to the closed
+    /// token range R.
+    auto expanded_tokens(clang::SourceRange range) -> TokenRange;
+
+    auto expansions_overlapping(TokenRange) -> std::vector<clang::syntax::TokenBuffer::Expansion>;
 
     /// Get the token length.
     auto token_length(clang::SourceLocation location) -> std::uint32_t;

include/Feature/Formatting.h

@@ -1 +1,13 @@
 #pragma once
+
+#include "AST/SourceCode.h"
+#include "Protocol/Feature/Formatting.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clice::feature {
+
+std::vector<proto::TextEdit> document_format(llvm::StringRef file,
+                                             llvm::StringRef content,
+                                             std::optional<LocalSourceRange>);
+
+}

include/Feature/InlayHint.h

@@ -50,8 +50,8 @@ struct InlayHint {
     std::vector<index::SymbolID> parts;
 };
 
-using InlayHints = std::vector<InlayHint>;
-
-InlayHints inlay_hints(CompilationUnit& unit, LocalSourceRange target);
+auto inlay_hint(CompilationUnit& unit,
+                LocalSourceRange target,
+                const config::InlayHintsOptions& options) -> std::vector<InlayHint>;
 
 }  // namespace clice::feature

include/Feature/SignatureHelp.h

@@ -4,6 +4,7 @@
 #include <cstdint>
 
 #include "llvm/ADT/StringRef.h"
+#include "Protocol/Feature/SignatureHelp.h"
 
 namespace clice {
 
@@ -17,12 +18,8 @@ struct SignatureHelpOption {};
 
 namespace feature {
 
-struct SignatureHelpItem {};
-
-using SignatureHelpResult = std::vector<SignatureHelpItem>;
-
-SignatureHelpResult signatureHelp(CompilationParams& params,
-                                  const config::SignatureHelpOption& option);
+proto::SignatureHelp signature_help(CompilationParams& params,
+                                    const config::SignatureHelpOption& option);
 
 }  // namespace feature
 

include/Protocol/Basic.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <string>
 #include <vector>
 #include <cstdint>

include/Protocol/Feature/Formatting.h

@@ -8,6 +8,19 @@ struct DocumentFormattingClientCapabilities {};
 
 using DocumentFormattingOptions = bool;
 
+struct DocumentFormattingParams {
+    /// The document to format.
+    TextDocumentIdentifier textDocument;
+};
+
+struct DocumentRangeFormattingParams {
+    /// The document to format.
+    TextDocumentIdentifier textDocument;
+
+    /// The range to format
+    Range range;
+};
+
 struct DocumentRangeFormattingClientCapabilities {};
 
 using DocumentRangeFormattingOptions = bool;

include/Protocol/Feature/InlayHint.h

@@ -4,12 +4,71 @@
 
 namespace clice::proto {
 
-struct InlayHintClientCapabilities {};
+struct InlayHintClientCapabilities {
+    /// Indicates which properties a client can resolve lazily on an inlay hint.
+    struct {
+        /// The properties that a client can resolve lazily.
+        array<string> properties;
+    } resolveSupport;
+};
 
 struct InlayHintOptions {
     /// The server provides support to resolve additional
     /// information for an inlay hint item.
     bool resolveProvider;
 };
 
+struct InlayHintParams {
+    /// The text document.
+    TextDocumentIdentifier textDocument;
+
+    /// The visible document range for which inlay hints should be computed.
+    Range range;
+};
+
+enum class InlayHintKind {
+    /// An inlay hint that for a type annotation.
+    Type = 1,
+
+    /// An inlay hint that is for a parameter.
+    Parameter = 2,
+};
+
+struct InlayHintLabelPart {
+    /// The value of this label part.
+    string value;
+
+    /// An optional source code location that represents this
+    /// label part.
+    ///
+    /// The editor will use this location for the hover and for code navigation
+    /// features: This part will become a clickable link that resolves to the
+    /// definition of the symbol at the given location (not necessarily the
+    /// location itself), it shows the hover that shows at the given location,
+    /// and it shows a context menu with further code navigation commands.
+    ///
+    /// Depending on the client capability `inlayHint.resolveSupport` clients
+    /// might resolve this property late using the resolve request.
+    /// FIXME: Location location;
+};
+
+struct InlayHint {
+    /// The position of this hint.
+    ///
+    /// If multiple hints have the same position, they will be shown in the order
+    /// they appear in the response.
+    Position position;
+
+    /// The label of this hint. A human readable string or an array of
+    /// InlayHintLabelPart label parts.
+    ///
+    /// *Note* that neither the string nor the label part can be empty.
+    /// TODO: Use label
+    array<InlayHintLabelPart> label;
+
+    /// The kind of this hint. Can be omitted in which case the client
+    ///  should fall back to a reasonable default.
+    InlayHintKind kind;
+};
+
 }  // namespace clice::proto