Merge pull request #1077 from julia-vscode/sp/inlay-hints

Initial InlayHint provider implementation

Author: pfitzseb

src/languageserverinstance.jl

@@ -43,6 +43,9 @@ mutable struct LanguageServerInstance
     lint_missingrefs::Symbol
     lint_disableddirs::Vector{String}
     completion_mode::Symbol
+    inlay_hints::Bool
+    inlay_hints_variable_types::Bool
+    inlay_hints_parameter_names::Symbol
 
     combined_msg_queue::Channel{Any}
 
@@ -73,7 +76,7 @@ mutable struct LanguageServerInstance
             Dict{URI,Document}(),
             env_path,
             depot_path,
-            SymbolServer.SymbolServerInstance(depot_path, symserver_store_path; symbolcache_upstream = symbolcache_upstream),
+            SymbolServer.SymbolServerInstance(depot_path, symserver_store_path; symbolcache_upstream=symbolcache_upstream),
             Channel(Inf),
             StaticLint.ExternalEnv(deepcopy(SymbolServer.stdlibs), SymbolServer.collect_extended_methods(SymbolServer.stdlibs), collect(keys(SymbolServer.stdlibs))),
             Dict(),
@@ -83,6 +86,9 @@ mutable struct LanguageServerInstance
             :all,
             LINT_DIABLED_DIRS,
             :qualify, # options: :import or :qualify, anything else turns this off
+            true,
+            true,
+            :literals,
             Channel{Any}(Inf),
             err_handler,
             :created,
@@ -184,7 +190,7 @@ function trigger_symbolstore_reload(server::LanguageServerInstance)
         ssi_ret, payload = SymbolServer.getstore(
             server.symbol_server,
             server.env_path,
-            function (msg, percentage = missing)
+            function (msg, percentage=missing)
                 if server.clientcapability_window_workdoneprogress && server.current_symserver_progress_token !== nothing
                     msg = ismissing(percentage) ? msg : string(msg, " ($percentage%)")
                     JSONRPC.send(
@@ -196,7 +202,7 @@ function trigger_symbolstore_reload(server::LanguageServerInstance)
                 @info msg
             end,
             server.err_handler,
-            download = server.symserver_use_download
+            download=server.symserver_use_download
         )
 
         server.number_of_outstanding_symserver_requests -= 1
@@ -289,7 +295,7 @@ function Base.run(server::LanguageServerInstance; timings = [])
         add_timer_message!(did_show_timer, timings, "(async) listening to client events")
         while true
             msg = JSONRPC.get_next_message(server.jr_endpoint)
-            put!(server.combined_msg_queue, (type = :clientmsg, msg = msg))
+            put!(server.combined_msg_queue, (type=:clientmsg, msg=msg))
         end
     catch err
         bt = catch_backtrace()
@@ -300,7 +306,7 @@ function Base.run(server::LanguageServerInstance; timings = [])
         end
     finally
         if isopen(server.combined_msg_queue)
-            put!(server.combined_msg_queue, (type = :close,))
+            put!(server.combined_msg_queue, (type=:close,))
             close(server.combined_msg_queue)
         end
         @debug "LS: Client listener task done."
@@ -312,7 +318,7 @@ function Base.run(server::LanguageServerInstance; timings = [])
         add_timer_message!(did_show_timer, timings, "(async) listening to symbol server events")
         while true
             msg = take!(server.symbol_results_channel)
-            put!(server.combined_msg_queue, (type = :symservmsg, msg = msg))
+            put!(server.combined_msg_queue, (type=:symservmsg, msg=msg))
         end
     catch err
         bt = catch_backtrace()
@@ -323,7 +329,7 @@ function Base.run(server::LanguageServerInstance; timings = [])
         end
     finally
         if isopen(server.combined_msg_queue)
-            put!(server.combined_msg_queue, (type = :close,))
+            put!(server.combined_msg_queue, (type=:close,))
             close(server.combined_msg_queue)
         end
         @debug "LS: Symbol server listener task done."
@@ -371,6 +377,7 @@ function Base.run(server::LanguageServerInstance; timings = [])
     msg_dispatcher[julia_getDocFromWord_request_type] = request_wrapper(julia_getDocFromWord_request, server)
     msg_dispatcher[textDocument_selectionRange_request_type] = request_wrapper(textDocument_selectionRange_request, server)
     msg_dispatcher[textDocument_documentLink_request_type] = request_wrapper(textDocument_documentLink_request, server)
+    msg_dispatcher[textDocument_inlayHint_request_type] = request_wrapper(textDocument_inlayHint_request, server)
 
     # The exit notification message should not be wrapped in request_wrapper (which checks
     # if the server have been requested to be shut down). Instead, this message needs to be

src/protocol/features.jl

@@ -296,6 +296,49 @@ end
     arguments::Union{Vector{Any},Missing}
 end
 
+##############################################################################
+# inlay hints
+@dict_readable struct InlayHintOptions <: Outbound
+    workDoneToken::Union{Int,String,Missing} # ProgressToken
+    resolveProvider::Bool
+end
+
+@dict_readable struct InlayHintRegistrationOptions <: Outbound
+    workDoneToken::Union{Int,String,Missing} # ProgressToken
+    resolveProvider::Bool # InlayHintOptions
+    id::Union{Missing, String} # StaticRegistrationOptions
+    documentSelector::Union{Nothing, DocumentSelector} # TextDocumentRegistrationOptions
+end
+
+@dict_readable struct InlayHintParams <: Outbound
+    textDocument::TextDocumentIdentifier
+    range::Range
+    workDoneToken::Union{Int,String,Missing} # ProgressToken
+end
+
+@dict_readable struct InlayHintLabelPart <: Outbound
+    value::String
+    tooltip::Union{Missing, String, MarkupContent}
+    location::Union{Missing, Location}
+    command::Union{Missing, Command}
+end
+
+const InlayHintKind = Int
+const InlayHintKinds = (
+    Type = 1,
+    Parameter = 2
+)
+
+@dict_readable struct InlayHint <: Outbound
+    position::Position
+    label::Union{String, Vector{InlayHintLabelPart}}
+    kind::Union{Missing, InlayHintKind}
+    textEdits::Union{Missing, Vector{TextEdit}}
+    tooltip::Union{Missing, String, MarkupContent}
+    paddingLeft::Union{Missing, Bool}
+    paddingRight::Union{Missing, Bool}
+    data::Union{Missing, Any}
+end
 
 ##############################################################################
 

src/protocol/initialize.jl

@@ -183,6 +183,7 @@ struct ServerCapabilities <: Outbound
     foldingRangeProvider::Union{Bool,FoldingRangeOptions,FoldingRangeRegistrationOptions,Missing}
     executeCommandProvider::Union{ExecuteCommandOptions,Missing}
     selectionRangeProvider::Union{Bool,SelectionRangeOptions,SelectionRangeRegistrationOptions,Missing}
+    inlayHintProvider::Union{Bool,InlayHintOptions,InlayHintRegistrationOptions}
     workspaceSymbolProvider::Union{Bool,Missing}
     workspace::Union{WorkspaceOptions,Missing}
     experimental::Union{Any,Missing}

src/protocol/messagedefs.jl

@@ -19,6 +19,7 @@ const textDocument_willSaveWaitUntil_request_type = JSONRPC.RequestType("textDoc
 const textDocument_publishDiagnostics_notification_type = JSONRPC.NotificationType("textDocument/publishDiagnostics", PublishDiagnosticsParams)
 const textDocument_selectionRange_request_type = JSONRPC.RequestType("textDocument/selectionRange", SelectionRangeParams, Union{Vector{SelectionRange}, Nothing})
 const textDocument_documentLink_request_type = JSONRPC.RequestType("textDocument/documentLink", DocumentLinkParams, Union{Vector{DocumentLink}, Nothing})
+const textDocument_inlayHint_request_type = JSONRPC.RequestType("textDocument/inlayHint", InlayHintParams, Union{Vector{InlayHint}, Nothing})
 
 const workspace_executeCommand_request_type = JSONRPC.RequestType("workspace/executeCommand", ExecuteCommandParams, Any)
 const workspace_symbol_request_type = JSONRPC.RequestType("workspace/symbol", WorkspaceSymbolParams, Union{Vector{SymbolInformation}, Nothing})

src/requests/features.jl

@@ -576,3 +576,100 @@ function get_selection_range_of_expr(x::EXPR)
     l2, c2 = get_position_from_offset(doc, offset + x.span)
     SelectionRange(Range(l1, c1, l2, c2), get_selection_range_of_expr(x.parent))
 end
+
+function textDocument_inlayHint_request(params::InlayHintParams, server::LanguageServerInstance, conn)::Union{Vector{InlayHint},Nothing}
+    if !server.inlay_hints
+        return nothing
+    end
+
+    doc = getdocument(server, params.textDocument.uri)
+
+    start, stop = get_offset(doc, params.range.start), get_offset(doc, params.range.stop)
+
+    return collect_inlay_hints(getcst(doc), server, doc, start, stop)
+end
+
+function collect_inlay_hints(x::EXPR, server::LanguageServerInstance, doc, start, stop, pos=0, hints=InlayHint[])
+    if x isa EXPR && parentof(x) isa EXPR &&
+            CSTParser.iscall(parentof(x)) &&
+            !(
+                parentof(parentof(x)) isa EXPR &&
+                CSTParser.defines_function(parentof(parentof(x)))
+            ) &&
+            parentof(x).args[1] != x # function calls
+
+        if server.inlay_hints_parameter_names === :all || (
+                server.inlay_hints_parameter_names === :literals &&
+                CSTParser.isliteral(x)
+            )
+            sigs = collect_signatures(x, doc, server)
+            if !isempty(sigs)
+                args = length(parentof(x).args) - 1
+                if args > 0
+                    filter!(s -> length(s.parameters) == args, sigs)
+                    if !isempty(sigs)
+                        pars = first(sigs).parameters
+                        thisarg = 0
+                        for a in parentof(x).args
+                            if x == a
+                                break
+                            end
+                            thisarg += 1
+                        end
+                        if thisarg <= args && thisarg <= length(pars)
+                            label = pars[thisarg].label
+                            if label == "#unused#"
+                                label = "_"
+                            end
+                            push!(
+                                hints,
+                                InlayHint(
+                                    Position(get_position_from_offset(doc, pos)...),
+                                    string(label, ':'),
+                                    InlayHintKinds.Parameter,
+                                    missing,
+                                    pars[thisarg].documentation,
+                                    false,
+                                    true,
+                                    missing
+                                )
+                            )
+                        end
+                    end
+                end
+            end
+        end
+    elseif x isa EXPR && parentof(x) isa EXPR &&
+            CSTParser.isassignment(parentof(x)) &&
+            parentof(x).args[1] == x &&
+            StaticLint.hasbinding(x) # assignment
+        if server.inlay_hints_variable_types
+            typ = _completion_type(StaticLint.bindingof(x))
+            if typ !== missing
+                push!(
+                    hints,
+                    InlayHint(
+                        Position(get_position_from_offset(doc, pos + x.span)...),
+                        string("::", typ),
+                        InlayHintKinds.Type,
+                        missing,
+                        missing,
+                        missing,
+                        missing,
+                        missing
+                    )
+                )
+            end
+        end
+    end
+    if length(x) > 0
+        for a in x
+            if pos < stop && pos + a.fullspan > start
+                collect_inlay_hints(a, server, doc, start, stop, pos, hints)
+            end
+            pos += a.fullspan
+            pos > stop && break
+        end
+    end
+    return hints
+end

src/requests/init.jl

@@ -31,6 +31,7 @@ function ServerCapabilities(client::ClientCapabilities)
         ExecuteCommandOptions(missing, collect(keys(LSActions))),
         true,
         true,
+        true,
         WorkspaceOptions(WorkspaceFoldersOptions(true, true)),
         missing
     )

src/requests/signatures.jl

@@ -10,7 +10,29 @@ function textDocument_signatureHelp_request(params::TextDocumentPositionParams,
     index_at(get_text_document(doc), params.position)
     offset = get_offset(doc, params.position)
     x = get_expr(getcst(doc), offset)
-    arg = 0
+
+    sigs = collect_signatures(x, doc, server)
+
+    if (isempty(sigs) || (headof(x) === :RPAREN))
+        return SignatureHelp(SignatureInformation[], 0, 0)
+    end
+
+    arg = fcall_arg_number(x)
+
+    return SignatureHelp(filter(s -> length(s.parameters) > arg, sigs), 0, arg)
+end
+
+function fcall_arg_number(x)
+    if headof(x) === :LPAREN
+        0
+    else
+        sum(headof(a) === :COMMA for a in parentof(x).trivia)
+    end
+end
+
+function collect_signatures(x, doc, server)
+    sigs = SignatureInformation[]
+
     if x isa EXPR && parentof(x) isa EXPR && CSTParser.iscall(parentof(x))
         if CSTParser.isidentifier(parentof(x).args[1])
             call_name = parentof(x).args[1]
@@ -25,22 +47,13 @@ function textDocument_signatureHelp_request(params::TextDocumentPositionParams,
             get_signatures(f_binding, tls, sigs, getenv(doc, server))
         end
     end
-    if (isempty(sigs) || (headof(x) === :RPAREN))
-        return SignatureHelp(SignatureInformation[], 0, 0)
-    end
 
-    if headof(x) === :LPAREN
-        arg = 0
-    else
-        arg = sum(headof(a) === :COMMA for a in parentof(x).trivia)
-    end
-    return SignatureHelp(filter(s -> length(s.parameters) > arg, sigs), 0, arg)
+    return sigs
 end
 
 function get_signatures(b, tls::StaticLint.Scope, sigs::Vector{SignatureInformation}, env) end
 
 function get_signatures(b::StaticLint.Binding, tls::StaticLint.Scope, sigs::Vector{SignatureInformation}, env)
-
     if b.val isa StaticLint.Binding
         get_signatures(b.val, tls, sigs, env)
     end

src/requests/workspace.jl

@@ -107,7 +107,10 @@ function request_julia_config(server::LanguageServerInstance, conn)
         ConfigurationItem(missing, "julia.lint.run"),
         ConfigurationItem(missing, "julia.lint.missingrefs"),
         ConfigurationItem(missing, "julia.lint.disabledDirs"),
-        ConfigurationItem(missing, "julia.completionmode")
+        ConfigurationItem(missing, "julia.completionmode"),
+        ConfigurationItem(missing, "julia.inlayHints.static.enabled"),
+        ConfigurationItem(missing, "julia.inlayHints.static.variableTypes.enabled"),
+        ConfigurationItem(missing, "julia.inlayHints.static.parameterNames.enabled"),
     ]))
 
     new_runlinter = something(response[11], true)
@@ -116,6 +119,9 @@ function request_julia_config(server::LanguageServerInstance, conn)
     new_lint_missingrefs = Symbol(something(response[12], :all))
     new_lint_disableddirs = something(response[13], LINT_DIABLED_DIRS)
     new_completion_mode = Symbol(something(response[14], :import))
+    inlayHints = something(response[15], true)
+    inlayHintsVariableTypes = something(response[16], true)
+    inlayHintsParameterNames = Symbol(something(response[17], :literals))
 
     rerun_lint = begin
         any(getproperty(server.lint_options, opt) != getproperty(new_SL_opts, opt) for opt in fieldnames(StaticLint.LintOptions)) ||
@@ -129,6 +135,9 @@ function request_julia_config(server::LanguageServerInstance, conn)
     server.lint_missingrefs = new_lint_missingrefs
     server.lint_disableddirs = new_lint_disableddirs
     server.completion_mode = new_completion_mode
+    server.inlay_hints = inlayHints
+    server.inlay_hints_variable_types = inlayHintsVariableTypes
+    server.inlay_hints_parameter_names = inlayHintsParameterNames
 
     if rerun_lint
         relintserver(server)

src/utilities.jl

@@ -200,6 +200,32 @@ function get_expr(x, offset::UnitRange{Int}, pos=0, ignorewhitespace=false)
     end
 end
 
+get_inner_expr(doc::Document, rng::Range) = get_inner_expr(getcst(doc), get_offset(doc, rng))
+# full (not only trivia) expr containing rng, modulo whitespace
+function get_inner_expr(x, rng::UnitRange{Int}, pos=0, pos_span = 0)
+    if all(pos .> rng)
+        return nothing
+    end
+    if length(x) > 0 && headof(x) !== :NONSTDIDENTIFIER
+        pos_span′ = pos_span
+        for a in x
+            if a in x.args && all(pos_span′ .< rng .<= (pos + a.fullspan))
+                return get_inner_expr(a, rng, pos, pos_span′)
+            end
+            pos += a.fullspan
+            pos_span′ = pos - (a.fullspan - a.span)
+        end
+    elseif pos == 0
+        return x
+    elseif all(pos_span .< rng .<= (pos + x.fullspan))
+        return x
+    end
+    pos -= x.fullspan
+    if all(pos_span .< rng .<= (pos + x.fullspan))
+        return x
+    end
+end
+
 function get_expr1(x, offset, pos=0)
     if length(x) == 0 || headof(x) === :NONSTDIDENTIFIER
         if pos <= offset <= pos + x.span

test/requests/test_features.jl

@@ -93,7 +93,7 @@ end
 
 @testitem "doc symbols" begin
     include("../test_shared_server.jl")
-    
+
     doc = settestdoc("""
     a = 1
     b = 2