Merge branch 'master' into fix-io-error

Author: davidanthoff

src/LanguageServer.jl

@@ -19,14 +19,14 @@ include("languageserverinstance.jl")
 include("runserver.jl")
 include("staticlint.jl")
 
-include("requests/init.jl")
 include("requests/misc.jl")
 include("requests/textdocument.jl")
 include("requests/features.jl")
 include("requests/hover.jl")
 include("requests/completions.jl")
 include("requests/workspace.jl")
 include("requests/actions.jl")
+include("requests/init.jl")
 include("utilities.jl")
 
 end

src/requests/actions.jl

@@ -1,3 +1,9 @@
+struct ServerAction
+    command::Command
+    when::Function
+    handler::Function
+end
+
 function textDocument_codeAction_request(params::CodeActionParams, server::LanguageServerInstance, conn)
     commands = Command[]
     doc = getdocument(server, URI2(params.textDocument.uri))
@@ -6,28 +12,12 @@ function textDocument_codeAction_request(params::CodeActionParams, server::Langu
     x = get_expr(getcst(doc), offset)
     arguments = Any[params.textDocument.uri, offset, offset1] # use the same arguments for all commands
     if x isa EXPR
-        if refof(x) isa StaticLint.Binding && refof(x).val isa SymbolServer.ModuleStore
-            push!(commands, Command("Explicitly import used package variables.", "ExplicitPackageVarImport", arguments))
-        end
-        if parentof(x) isa EXPR && typof(parentof(x)) === CSTParser.Using &&  refof(x) isa StaticLint.Binding
-            if refof(x).type === StaticLint.CoreTypes.Module || (refof(x).val isa StaticLint.Binding && refof(x).val.type === StaticLint.CoreTypes.Module) || refof(x).val isa SymbolServer.ModuleStore
-                push!(commands, Command("Re-export package variables.", "ReexportModule", arguments))
+        for (_,sa) in LSActions
+            if sa.when(x, params)
+                push!(commands, Command(sa.command.title, sa.command.command, arguments))
             end
         end
-        if is_in_fexpr(x, is_single_line_func)
-            push!(commands, Command("Expand function definition.", "ExpandFunction", arguments))
-        end
-        if is_in_fexpr(x, CSTParser.defines_struct)
-            push!(commands, Command("Add default constructor", "AddDefaultConstructor", arguments))
-        end
-        if is_fixable_missing_ref(x, params.context)
-            push!(commands, Command("Fix missing reference", "FixMissingRef", arguments))
-        end
-        # if params.range.start.line != params.range.stop.line # selection across _line_offsets
-        #     push!(commands, Command("Wrap in `if` block.", "WrapIfBlock", arguments))
-        # end
     end
-
     return commands
 end
 
@@ -36,22 +26,8 @@ function workspace_executeCommand_request(params::ExecuteCommandParams, server::
     offset = params.arguments[2]
     doc = getdocument(server, URI2(uri))
     x = get_expr(getcst(doc), offset)
-    if params.command == "ExplicitPackageVarImport"
-        explicitly_import_used_variables(x, server, conn)
-    elseif params.command == "ExpandFunction"
-        expand_inline_func(x, server, conn)
-    elseif params.command == "AddDefaultConstructor"
-        add_default_constructor(x, server, conn)
-    elseif params.command == "ReexportModule"
-        if refof(x).type === StaticLint.CoreTypes.Module || (refof(x).val isa StaticLint.Binding && refof(x).val.type === StaticLint.CoreTypes.Module)
-            reexport_module(x, server, conn)
-        elseif refof(x).val isa SymbolServer.ModuleStore
-            reexport_package(x, server, conn)
-        end
-    elseif params.command == "WrapIfBlock"
-        wrap_block(get_expr(getcst(doc), params.arguments[2]:params.arguments[3]), server, :if, conn)
-    elseif params.command == "FixMissingRef"
-        applymissingreffix(x, server, conn)
+    if haskey(LSActions, params.command)
+        LSActions[params.command].handler(x, server, conn)
     end
 end
 
@@ -72,14 +48,13 @@ function explicitly_import_used_variables(x::EXPR, server, conn)
 
     tdes = Dict{String,TextDocumentEdit}()
     vars = Set{String}() # names that need to be imported
-
     # Find uses of `x` and mark edits
     for ref in refof(x).refs
         if parentof(ref) isa EXPR && typof(parentof(ref)) == CSTParser.BinaryOpCall && length(parentof(ref).args) == 3 && kindof(parentof(ref).args[2]) === CSTParser.Tokens.DOT && parentof(ref).args[1] == ref
             typof(parentof(ref).args[3]) !== CSTParser.Quotenode && continue # some malformed EXPR, skip
             childname = parentof(ref).args[3].args[1]
             StaticLint.hasref(childname) && refof(childname) isa StaticLint.Binding && continue # check this isn't the name of something being explictly overwritten
-            !haskey(refof(x).val.vals, valof(childname)) && continue # skip, perhaps mark as missing ref ?
+            !haskey(refof(x).val.vals, Symbol(valof(childname))) && continue # skip, perhaps mark as missing ref ?
 
             file, offset = get_file_loc(ref)
             if !haskey(tdes, file._uri)
@@ -147,33 +122,6 @@ function expand_inline_func(x, server, conn)
     end
 end
 
-
-function add_default_constructor(x::EXPR, server, conn)
-    sexpr = _get_parent_fexpr(x, CSTParser.defines_struct)
-    !(sexpr.args isa Vector{EXPR}) && return
-    ismutable = length(sexpr.args) == 5
-    name = CSTParser.get_name(sexpr)
-    sig = sexpr.args[2 + ismutable]
-    block = sexpr.args[3 + ismutable]
-
-    isempty(block.args) && return
-    any(CSTParser.defines_function(a) for a in block.args) && return # constructor already exists
-
-    newtext = string("\n    function $(valof(name))(args...)\n\n        new")
-    # if DataType is parameterised do something here
-
-    newtext = string(newtext, "(")
-    for i in 1:length(block.args)
-        newtext = string(newtext, "", valof(CSTParser.get_arg_name(block.args[i])))
-        newtext = string(newtext, i < length(block.args) ? ", " : ")\n    end")
-    end
-    file, offset = get_file_loc(last(block.args))
-    offset += last(block.args).span
-    tde = TextDocumentEdit(VersionedTextDocumentIdentifier(file._uri, file._version), TextEdit[TextEdit(Range(file, offset:offset), newtext)])
-
-    JSONRPC.send(conn, workspace_applyEdit_request_type, ApplyWorkspaceEditParams(missing, WorkspaceEdit(missing, TextDocumentEdit[tde])))
-end
-
 function is_in_fexpr(x::EXPR, f)
     if f(x)
         return true
@@ -205,6 +153,7 @@ function get_next_line_offset(x)
 end
 
 function reexport_package(x::EXPR, server, conn)
+    (refof(x).type === StaticLint.CoreTypes.Module || (refof(x).val isa StaticLint.Binding && refof(x).val.type === StaticLint.CoreTypes.Module)) || (refof(x).val isa SymbolServer.ModuleStore) || return
     mod::SymbolServer.ModuleStore = refof(x).val
     using_stmt = parentof(x)
     file, offset = get_file_loc(x)
@@ -301,3 +250,22 @@ function applymissingreffix(x, server, conn)
         end
     end
 end
+
+# Adding a CodeAction requires defining:
+# * a Command (title and description);
+# * a function (.when) called on the currently selected expression and parameters of the CodeAction call;
+# * a function (.handler) called on three arguments (current expression, server and the jr connection) to implement the command.
+const LSActions = Dict(
+    "ExplicitPackageVarImport" => ServerAction(Command("Explicitly import used package variables.", "ExplicitPackageVarImport", missing), 
+                                               (x, params) -> refof(x) isa StaticLint.Binding && refof(x).val isa SymbolServer.ModuleStore, 
+                                               explicitly_import_used_variables),
+    "ExpandFunction" => ServerAction(Command("Expand function definition.", "ExpandFunction", missing),
+                                     (x, params) -> is_in_fexpr(x, is_single_line_func),
+                                     expand_inline_func),
+    "FixMissingRef" => ServerAction(Command("Fix missing reference", "FixMissingRef", missing),
+                                    (x, params) -> is_fixable_missing_ref(x, params.context),
+                                    applymissingreffix),
+    "ReexportModule" => ServerAction(Command("Re-export package variables.", "ReexportModule", missing), 
+                                     (x, params) -> parentof(x) isa EXPR && typof(parentof(x)) === CSTParser.Using &&  refof(x) isa StaticLint.Binding && (refof(x).type === StaticLint.CoreTypes.Module || (refof(x).val isa StaticLint.Binding && refof(x).val.type === StaticLint.CoreTypes.Module) || refof(x).val isa SymbolServer.ModuleStore),
+                                     reexport_package)
+)

src/requests/init.jl

@@ -23,7 +23,7 @@ const serverCapabilities = ServerCapabilities(
     missing,
     true,
     false,
-    ExecuteCommandOptions(missing, String["ExplicitPackageVarImport", "ExpandFunction", "AddDefaultConstructor", "ReexportModule", "FixMissingRef"]),
+    ExecuteCommandOptions(missing, collect(keys(LSActions))),
     false,
     true,
     WorkspaceOptions(WorkspaceFoldersOptions(true, true)),

test/requests/actions.jl

@@ -0,0 +1,45 @@
+action_request_test(line0, char0, line1 = line0, char1 = char0; diags = []) = LanguageServer.textDocument_codeAction_request(LanguageServer.CodeActionParams(LanguageServer.TextDocumentIdentifier("testdoc"), LanguageServer.Range(LanguageServer.Position(line0, char0), LanguageServer.Position(line1, char1)), LanguageServer.CodeActionContext(diags, missing)), server, server.jr_endpoint)
+
+@testset "reexport" begin
+    settestdoc("using Base.Meta\n")
+    @test any(c.command == "ReexportModule" for c in action_request_test(0, 15))
+    c = filter(c->c.command == "ReexportModule", action_request_test(0, 15))[1]
+    
+    LanguageServer.workspace_executeCommand_request(LanguageServer.ExecuteCommandParams(missing, c.command, c.arguments), server, server.jr_endpoint)
+end
+
+@testset "inline expand" begin
+    settestdoc("f(x) = x")
+    @test any(c.command == "ExpandFunction" for c in action_request_test(0, 5))
+    c = filter(c->c.command == "ExpandFunction", action_request_test(0, 5))[1]
+    
+    LanguageServer.workspace_executeCommand_request(LanguageServer.ExecuteCommandParams(missing, c.command, c.arguments), server, server.jr_endpoint)
+
+    settestdoc("f(x) = begin x end")
+    @test any(c.command == "ExpandFunction" for c in action_request_test(0, 5))
+    c = filter(c->c.command == "ExpandFunction", action_request_test(0, 5))[1]
+    
+    LanguageServer.workspace_executeCommand_request(LanguageServer.ExecuteCommandParams(missing, c.command, c.arguments), server, server.jr_endpoint)
+end
+
+@testset "fixmissingref" begin
+    doc = settestdoc("argtail\n")
+    e = LanguageServer.mark_errors(doc)[1]
+    @test any(c.command == "FixMissingRef" for c in action_request_test(0, 5, diags = [e]))
+    c = filter(c->c.command == "FixMissingRef", action_request_test(0, 5, diags = [e]))[1]
+    
+    LanguageServer.workspace_executeCommand_request(LanguageServer.ExecuteCommandParams(missing, c.command, c.arguments), server, server.jr_endpoint)
+end
+
+@testset "explicit import" begin
+    doc = settestdoc("using Base.Meta\nMeta.quot")
+    @test LanguageServer.find_using_statement(doc.cst[2][1]) !== nothing
+    
+    @test any(c.command == "ExplicitPackageVarImport" for c in action_request_test(1, 1))
+    c = filter(c->c.command == "ExplicitPackageVarImport", action_request_test(1, 1))[1]
+    
+    LanguageServer.workspace_executeCommand_request(LanguageServer.ExecuteCommandParams(missing, c.command, c.arguments), server, server.jr_endpoint)
+end
+
+
+

test/requests/completions.jl

@@ -0,0 +1,125 @@
+completion_test(line, char) = LanguageServer.textDocument_completion_request(LanguageServer.CompletionParams(LanguageServer.TextDocumentIdentifier("testdoc"), LanguageServer.Position(line, char), missing), server, server.jr_endpoint)
+
+@testset "latex completions" begin
+    settestdoc("""
+    \\therefor
+    .\\therefor
+    #\\therefor
+    "\\therefor"
+    \"\"\"\\therefor\"\"\"
+    ^\\therefor
+    """)
+    @test completion_test(0, 9).items[1].textEdit.newText == "∴"
+    @test completion_test(0, 9).items[1].textEdit.range == LanguageServer.Range(0, 0, 0, 9)
+    
+    @test completion_test(1, 10).items[1].textEdit.newText == "∴"
+    @test completion_test(1, 10).items[1].textEdit.range == LanguageServer.Range(1, 1, 1, 10)
+    
+    @test completion_test(2, 10).items[1].textEdit.newText == "∴"
+    @test completion_test(2, 10).items[1].textEdit.range == LanguageServer.Range(2, 1, 2, 10)
+    
+    @test completion_test(3, 10).items[1].textEdit.newText == "∴"
+    @test completion_test(3, 10).items[1].textEdit.range == LanguageServer.Range(3, 1, 3, 10)
+    
+    @test completion_test(4, 12).items[1].textEdit.newText == "∴"
+    @test completion_test(4, 12).items[1].textEdit.range == LanguageServer.Range(4, 3, 4, 12)
+
+    @test completion_test(5, 10).items[1].textEdit.newText == "∴"
+    @test completion_test(5, 10).items[1].textEdit.range == LanguageServer.Range(5, 1, 5, 10)
+end
+
+@testset "path completions" begin
+end
+
+@testset "import completions" begin
+    settestdoc("import Base: r")
+    @test any(item.label == "rand" for item in completion_test(0, 14).items)
+
+    settestdoc("import ")
+    @test all(item.label in ("Main", "Base", "Core") for item in completion_test(0, 7).items)
+    
+    settestdoc("""module M end
+    import .""")
+    @test_broken completion_test(1, 8).items[1].label == "M"
+
+    settestdoc("import Base.")
+    @test any(item.label == "Meta" for item in completion_test(0, 12).items)
+
+    settestdoc("import Base.M")
+    @test any(item.label == "Meta" for item in completion_test(0, 13).items)
+
+    settestdoc("import Bas")
+    @test any(item.label == "Base" for item in completion_test(0, 10).items)
+end
+
+@testset "getfield completions" begin
+    settestdoc("Base.")
+    @test any(item.label == "Base" for item in completion_test(0, 5).items)
+
+    settestdoc("Base.r")
+    @test any(item.label == "rand" for item in completion_test(0, 6).items)
+
+    settestdoc("""
+    using Base.Meta
+    Base.Meta.
+    """)
+    @test any(item.label == "quot" for item in completion_test(1, 10).items)
+
+    settestdoc("""
+    module M 
+    inner = 1
+    end
+    M.
+    """)
+    @test any(item.label == "inner" for item in completion_test(3, 2).items)
+
+    settestdoc("""
+    x = Expr()
+    x.
+    """)
+    @test all(item.label in ("head", "args") for item in completion_test(1, 2).items)
+
+    settestdoc("""
+    struct T
+        f1
+        f2
+    end
+    x = T()
+    x.
+    """)
+    @test all(item.label in ("f1", "f2") for item in completion_test(1, 2).items)
+end
+
+
+
+@testset "token completions" begin
+    settestdoc("B")
+    @test any(item.label == "Base" for item in completion_test(0, 1).items)
+
+    settestdoc("r")
+    @test any(item.label == "rand" for item in completion_test(0, 1).items)
+
+    settestdoc("@t")
+    @test any(item.label == "@time" for item in completion_test(0, 2).items)
+    
+    settestdoc("i")
+    @test any(item.label == "if" for item in completion_test(0, 1).items)
+    
+    settestdoc("i")
+    @test any(item.label == "in" for item in completion_test(0, 1).items)
+    
+    settestdoc("for")
+    @test any(item.label == "for" for item in completion_test(0, 3).items)
+
+    settestdoc("in")
+    @test any(item.label == "in" for item in completion_test(0, 2).items)
+    
+    settestdoc("isa")
+    @test any(item.label == "isa" for item in completion_test(0, 3).items)
+end
+
+@testset "scope var completions" begin
+    settestdoc("""myvar = 1
+    myv""")
+    @test any(item.label == "myvar" for item in completion_test(1, 3).items)
+end