Enable inlay hints (#183)

Author: 16bit-ykiko

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/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/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

include/Protocol/Lifecycle.h

@@ -163,7 +163,7 @@ struct ServerCapabilities {
     /// FIXME: InlineValueOptions inlineValueProvider;
 
     /// The server provides inlay hints.
-    /// FIXME: InlayHintOptions inlayHintProvider;
+    InlayHintOptions inlayHintProvider;
 
     /// The server has support for pull model diagnostics.
     /// FIXME: DiagnosticOptions diagnosticProvider;

include/Server/Server.h

@@ -208,6 +208,8 @@ class Server {
 
     async::Task<json::Value> on_semantic_token(proto::SemanticTokensParams params);
 
+    async::Task<json::Value> on_inlay_hint(proto::InlayHintParams params);
+
 private:
     /// The current request id.
     std::uint32_t id = 0;

include/Support/FileSystem.h

@@ -146,7 +146,7 @@ inline std::string toPath(llvm::StringRef uri) {
 
     llvm::SmallString<128> result;
     if(auto err = fs::real_path(decoded, result)) {
-        clice::print("Failed to get real path: {}, Input is {}\n", err.message(), decoded);
+        std::println("Failed to get real path: {}, Input is {}\n", err.message(), decoded);
         std::abort();
     }
 

include/Support/Format.h

@@ -1,25 +1,11 @@
 #pragma once
 
 #include <format>
-
+#include <print>
 #include "Support/JSON.h"
 #include "Support/Ranges.h"
 #include "llvm/Support/Error.h"
 
-namespace clice {
-
-template <typename... Args>
-void print(std::format_string<Args...> fmt, Args&&... args) {
-    llvm::outs() << std::vformat(fmt.get(), std::make_format_args(args...));
-}
-
-template <typename... Args>
-void println(std::format_string<Args...> fmt, Args&&... args) {
-    llvm::outs() << std::vformat(fmt.get(), std::make_format_args(args...)) << '\n';
-}
-
-}  // namespace clice
-
 template <>
 struct std::formatter<llvm::StringRef> : std::formatter<std::string_view> {
     using Base = std::formatter<std::string_view>;
@@ -171,7 +157,7 @@ std::string pretty_dump(const Object& object, std::size_t indent = 2) {
     std::string repr = dump(object);
     auto json = json::parse(repr);
     if(!json) {
-        clice::println("{} {}", json.takeError(), repr);
+        std::println("{} {}", json.takeError(), repr);
         std::abort();
     }
     llvm::SmallString<128> buffer = {std::format("{{0:{}}}", indent)};

include/Test/Test.h

@@ -84,16 +84,22 @@ struct may_failure {
     bool fatal = false;
     std::string expression;
     std::source_location location;
+    std::string message;
+
+    may_failure& operator<< (std::string message) {
+        this->message += std::move(message);
+        return *this;
+    }
 
     ~may_failure() {
         Runner::instance().fail(*this);
     }
 };
 
-inline struct {
+constexpr inline struct {
     template <typename TExpr>
     may_failure operator() (const TExpr& expr,
-                            std::source_location location = std::source_location::current()) {
+                            std::source_location location = std::source_location::current()) const {
         bool failed = false;
         std::string expression = "false";
 
@@ -115,16 +121,18 @@ inline struct {
     }
 } expect;
 
-inline struct {
-    test&& operator/ (test&& test) {
+constexpr inline struct {
+    test&& operator/ (test&& test) const {
         test.skipped = true;
         return std::move(test);
     }
 } skip;
 
-inline struct {
-    may_failure&& operator/ (may_failure&& failure) {
-        failure.fatal = true;
+constexpr inline struct {
+    may_failure&& operator/ (may_failure&& failure) const {
+        if(failure.failed) {
+            failure.fatal = true;
+        }
         return std::move(failure);
     }
 } fatal;