Nothing
readiness_catalogs <- provider_startup_s3
readiness_fixture <- function(content, .local_envir = parent.frame()) {
root <- withr::local_tempdir(.local_envir = .local_envir)
uri <- path_to_uri(file.path(root, "main.R"))
workspace <- testthat::with_mocked_bindings(Workspace$new(root),
workspace_startup_packages = function() startup_packages,
workspace_startup_s3 = readiness_catalogs,
.package = "languageserver")
document <- Document$new(uri, "r", 1L, content)
document$did_open()
workspace$documents$set(uri, document)
parsed <- parse_document(uri, content, include_xml = FALSE)
parsed$version <- document$version
workspace$update_parse_data(uri, parsed)
document$requested_packages <- list(packages = character(), namespace_packages = c("base", "pending"))
server <- new.env(parent = emptyenv())
server$get_workspace <- function(...) workspace
server$pending_replies <- collections::dict()
methods <- c("textDocument/completion", "textDocument/hover", "textDocument/signatureHelp")
server$pending_replies$set(uri, stats::setNames(lapply(methods, function(...) collections::queue()), methods))
server$request_handlers <- stats::setNames(list(text_document_completion, text_document_hover,
text_document_signature_help), methods)
server$replies <- list()
server$deliver <- function(response, ...) server$replies[[length(server$replies) + 1L]] <- response
server$resolve_task_manager <- list(has = function(...) TRUE, promote = function(...) NULL,
add_task = function(...) NULL)
server$parse_task_manager <- list(promote = function(...) NULL, add_task = function(...) NULL)
server$refresh_index_documents <- function(...) NULL
server$ClientCapabilities <- list()
list(server = server, workspace = workspace, document = document, uri = uri)
}
readiness_params <- function(fixture, row, col) {
list(textDocument = list(uri = fixture$uri), position = position(row, col))
}
readiness_package_fixture <- function() {
fixture <- readiness_fixture("findInterval(1, c(0, 2))", .local_envir = parent.frame())
workspace <- fixture$workspace
dir.create(file.path(workspace$root, "R"))
writeLines("Package: readinessfixture", file.path(workspace$root, "DESCRIPTION"))
workspace$documents$remove(fixture$uri)
workspace$index$remove(fixture$uri)
uri <- path_to_uri(file.path(workspace$root, "R", "main.R"))
document <- Document$new(uri, "r", 1L, fixture$document$content)
workspace$documents$set(uri, document)
parsed <- parse_document(uri, document$content, include_xml = FALSE)
parsed$version <- document$version
workspace$update_parse_data(uri, parsed)
fixture$uri <- uri
fixture$document <- document
fixture
}
readiness_peer <- function(fixture, name, content, full = TRUE) {
uri <- path_to_uri(file.path(fixture$workspace$root, "R", paste0(name, ".R")))
if (full) {
document <- Document$new(uri, "r", 1L, content)
fixture$workspace$documents$set(uri, document)
parsed <- parse_document(uri, content, include_xml = FALSE)
parsed$version <- document$version
fixture$workspace$update_parse_data(uri, parsed)
} else {
fixture$workspace$index$update_content(uri, content)
}
uri
}
ReadinessSyncServer <- R6::R6Class("ReadinessSyncServer",
inherit = LanguageServer,
private = list(finalize = function() NULL),
public = list(initialize = function(workspace) {
self$workspaces <- collections::dict()
self$workspaces$set(DEFAULT_WORKSPACE, workspace)
self$workspace_cache <- collections::dict()
self$pending_replies <- collections::dict()
})
)
readiness_masking_catalog <- function() {
list(schema = 1L, package = "masking", generation = "ready",
callables = "findInterval", objects = list(), dependencies = "base",
functions = list(findInterval = list(name = "findInterval", owner = "masking",
generic = list(name = "findInterval", formal = "x"), formals = as.pairlist(alist(x = , ... = )))),
methods = list("masking::findInterval.data.frame" = list(name = "findInterval.data.frame",
package = "masking", owner = "masking", generic = "findInterval", generic_package = "masking",
class = "data.frame", formals = as.pairlist(alist(x = , columns = NULL, ... = )))))
}
readiness_task_manager <- function() {
manager <- new.env(parent = emptyenv())
manager$tasks <- collections::dict()
manager$add_task <- function(uri, task) {
if (is.null(task)) manager$tasks$pop(uri, NULL) else manager$tasks$set(uri, task)
}
manager$cancel <- function(uri) manager$tasks$pop(uri, NULL)
manager$has <- function(uri) manager$tasks$has(uri)
manager$promote <- function(...) NULL
manager
}
test_that("open source documents repair startup S3 metadata without member preparation", {
previous <- stats::setNames(lapply(c("s3_dispatch", "member_completion"), lsp_settings$get),
c("s3_dispatch", "member_completion"))
withr::defer(for (key in names(previous)) lsp_settings$set(key, previous[[key]]))
lsp_settings$set("s3_dispatch", TRUE)
lsp_settings$set("member_completion", TRUE)
testthat::local_mocked_bindings(
s3_prepare_packages = function(...) readiness_catalogs(),
resolve_attached_packages = function(...) startup_packages,
member_prepare_package = function(...) stop("prepared a member model for startup recovery"),
.package = "languageserver")
lines <- c("g <- function(x, ...) UseMethod('g')",
"g.numeric <- function(x, digits=3, mode='short', ...) NULL", "g(1, )")
for (failed in c(FALSE, TRUE)) {
for (split in c(FALSE, TRUE)) {
fixture <- readiness_fixture(lines)
workspace <- fixture$workspace
document <- fixture$document
server <- fixture$server
server$resolve_task_manager <- readiness_task_manager()
if (split) server$member_task_manager <- readiness_task_manager()
workspace$s3_metadata <- S3MetadataCache$new()
if (failed) {
workspace$s3_metadata$set("base", list(schema = 1L, generation = "failed",
functions = list(), methods = list(), objects = list(), error = "Startup timed out"))
}
expect_null(resolve_s3_call(fixture$uri, workspace, document, list(row = 2L, col = 5L)))
document$requested_packages <- document$parse_data <- NULL
parsed <- parse_document(fixture$uri, document$content, include_xml = FALSE)
parse_callback(server, fixture$uri, document$version, parsed, cache = FALSE)
task <- server$resolve_task_manager$tasks$get(fixture$uri)
expect_s3_class(task, "Task")
private <- task$.__enclos_env__$private
expect_false(private$args$prepare)
expect_true(private$args$prepare_s3)
if (split) expect_false(server$member_task_manager$has(fixture$uri))
# Unchanged package requests keep the repair in flight, and its
# result remains useful after a source-only edit advances version.
document$set_content(2L, c(lines, "# another edit"))
parsed <- parse_document(fixture$uri, document$content, include_xml = FALSE)
parse_callback(server, fixture$uri, document$version, parsed, cache = FALSE)
expect_identical(server$resolve_task_manager$tasks$get(fixture$uri), task)
result <- do.call(private$target, private$args)
server$resolve_task_manager$cancel(fixture$uri)
private$callback(result)
resolved <- resolve_s3_call(fixture$uri, workspace, document, list(row = 2L, col = 5L))
expect_identical(resolved$method$name, "g.numeric")
text_document_completion(server, 1L, readiness_params(fixture, 2L, 5L))
labels <- vapply(tail(server$replies, 1L)[[1L]]$result$items, `[[`, "", "label")
expect_true(all(c("digits", "mode") %in% labels))
expect_null(resolve_task(server, fixture$uri, document, character()))
}
}
})
test_that("startup-only S3 resolution skips complete, disabled and background documents", {
previous <- lsp_settings$get("s3_dispatch")
withr::defer(lsp_settings$set("s3_dispatch", previous))
lsp_settings$set("s3_dispatch", TRUE)
fixture <- readiness_fixture("print(1)")
expect_null(resolve_task(fixture$server, fixture$uri, fixture$document, character()))
fixture$workspace$s3_metadata <- S3MetadataCache$new()
fixture$document$did_close()
expect_null(resolve_task(fixture$server, fixture$uri, fixture$document, character()))
fixture$document$did_open()
lsp_settings$set("s3_dispatch", FALSE)
fixture$server$get_workspace <- function(...) stop("looked up disabled startup resolution")
expect_null(resolve_task(fixture$server, fixture$uri, fixture$document, character()))
})
test_that("cached generic help survives missing or failed startup S3 metadata", {
fixture <- readiness_fixture(c("print()", "base::print()", "summary(1)"))
for (failed in c(FALSE, TRUE)) {
fixture$workspace$s3_metadata <- S3MetadataCache$new()
if (failed) {
for (package in startup_packages) {
fixture$workspace$s3_metadata$set(package, list(schema = 1L, generation = "failed",
functions = list(), callables = character(), methods = list(), objects = list(),
error = "Startup metadata timed out"))
}
}
fixture$server$replies <- list()
for (row in 0:2) {
col <- c(6L, 12L, 8L)[[row + 1L]]
text_document_signature_help(fixture$server, row * 2L + 1L, readiness_params(fixture, row, col))
text_document_hover(fixture$server, row * 2L + 2L, readiness_params(fixture, row, col - 4L))
}
expect_length(fixture$server$replies, 6L)
for (reply in fixture$server$replies) {
if (!is.null(reply$result$signatures)) {
expect_match(reply$result$signatures[[1L]]$label, "(print|summary)\\(")
} else {
expect_match(paste(reply$result$contents, collapse = " "), "print|summary")
}
}
expect_true(all(vapply(fixture$server$pending_replies$get(fixture$uri),
function(queue) queue$size() == 0L, logical(1L))))
}
fixture$document$set_content(2L, "print(data.frame(x = 1), )")
parsed <- parse_document(fixture$uri, fixture$document$content, include_xml = FALSE)
parsed$version <- fixture$document$version
fixture$workspace$update_parse_data(fixture$uri, parsed)
for (package in names(readiness_catalogs())) {
fixture$workspace$s3_metadata$set(package, readiness_catalogs()[[package]])
}
text_document_signature_help(fixture$server, 7L,
readiness_params(fixture, 0L, nchar(fixture$document$line0(0L)) - 1L))
expect_match(tail(fixture$server$replies, 1L)[[1L]]$result$signatures[[1L]]$label, "row.names = TRUE", fixed = TRUE)
})
test_that("basic function completion responds before and during document parsing", {
fixture <- readiness_fixture(c("pri", "value <- 1"))
fixture$server$ClientCapabilities <- list(textDocument = list(completion =
list(completionItem = list(snippetSupport = TRUE))))
# A cached namespace that has been unloaded must not be loaded by this path.
fixture$workspace$startup_packages <- c(startup_packages, "pending")
fixture$workspace$namespaces$set("pending", list(get_symbols = function(...) stop("loaded a cold namespace")))
testthat::local_mocked_bindings(member_completion = function(...) stop("waited for syntax"),
s3_call_packages = function(...) stop("scanned imports"), .package = "languageserver")
fixture$server$parse_task_manager$promote <- function(...) stop("waited for parse")
for (parsed in c(FALSE, TRUE)) {
if (!parsed) {
fixture$document$parse_data <- NULL
} else {
fixture$document$parse_data <- list(version = 1L)
fixture$document$set_content(2L, c("print", "value <- 1"))
}
text_document_completion(fixture$server, as.integer(parsed) + 1L,
readiness_params(fixture, 0L, nchar(fixture$document$line0(0L))))
result <- tail(fixture$server$replies, 1L)[[1L]]$result
expect_true(result$isIncomplete)
items <- Filter(function(item) identical(item$label, "print"), result$items)
expect_length(items, 1L)
expect_identical(items[[1L]]$kind, CompletionItemKind$Function)
expect_identical(items[[1L]]$insertText, "print($0)")
expect_identical(items[[1L]]$data, list(type = "function", package = "base",
context_uri = fixture$uri,
completion_position = list(row = 0L, col = nchar(fixture$document$line0(0L))),
completion_version = fixture$document$version))
expect_identical(fixture$server$pending_replies$get(fixture$uri)$`textDocument/completion`$size(), 0L)
}
})
test_that("Inline completion responds to rapid edits without waiting for full parsing", {
previous <- lsp_settings$get("completion_label_details")
withr::defer(lsp_settings$set("completion_label_details", previous))
lsp_settings$set("completion_label_details", TRUE)
fixture <- readiness_fixture(c("current <- function(argument = 1) NULL", "cur"))
fixture$server$ClientCapabilities <- list(textDocument = list(completion =
list(completionItem = list(labelDetailsSupport = TRUE))))
fixture$server$parse_task_manager$promote <- function(...) stop("Waited for full parsing")
testthat::local_mocked_bindings(completion_reply = function(...) stop("Used full completion"),
member_resolve_cursor = function(...) stop("Inferred source while typing"), .package = "languageserver")
for (size in c(0L, 10000L)) {
prefix <- sprintf("unused_%05d <- 1", seq_len(size))
for (version in seq_len(3L)) {
fixture$document$set_content(version + size + 1L,
c(prefix, sprintf("current <- function(argument = %d) NULL", version), c("c", "cu", "cur")[[version]]))
row <- length(fixture$document$content) - 1L
text_document_completion(fixture$server, version, readiness_params(fixture, row,
nchar(fixture$document$line0(row))))
reply <- tail(fixture$server$replies, 1L)[[1L]]$result
item <- Filter(function(item) identical(item$label, "current"), reply$items)[[1L]]
expect_identical(item$labelDetails$detail, sprintf("(argument = %d)", version))
expect_identical(item$data$completion_version, fixture$document$version)
expect_equal(fixture$server$pending_replies$get(fixture$uri)$`textDocument/completion`$size(), 0L)
}
}
})
test_that("the first preparse response includes current local declarations", {
fixture <- readiness_fixture(c("hello <- function(value) value", "hel"))
fixture$document$parse_data <- NULL
fixture$server$parse_task_manager$promote <- function(...) stop("waited for full parse")
text_document_completion(fixture$server, 1L, readiness_params(fixture, 1L, 3L))
expect_length(fixture$server$replies, 1L)
items <- fixture$server$replies[[1L]]$result$items
hello <- Filter(function(item) identical(item$label, "hello"), items)
expect_length(hello, 1L)
expect_identical(hello[[1L]]$kind, CompletionItemKind$Function)
expect_identical(hello[[1L]]$data$uri, fixture$uri)
expect_identical(fixture$server$pending_replies$get(fixture$uri)$`textDocument/completion`$size(), 0L)
# A structural edit must replace the outline rather than preserve a stale
# declaration from the first response. No second request is needed to fix it.
fixture$document$set_content(2L, c("helpful <- function(value) value", "hel"))
text_document_completion(fixture$server, 2L, readiness_params(fixture, 1L, 3L))
names <- vapply(fixture$server$replies[[2L]]$result$items, `[[`, "", "label")
expect_true("helpful" %in% names)
expect_false("hello" %in% names)
fixture$document$set_content(3L, c("for (hello in 1:3) { hello <- hello + 1 }", "hel"))
text_document_completion(fixture$server, 3L, readiness_params(fixture, 1L, 3L))
hello <- Filter(function(item) identical(item$label, "hello"), fixture$server$replies[[3L]]$result$items)
expect_length(hello, 1L)
expect_identical(hello[[1L]]$kind, CompletionItemKind$Field)
})
test_that("preparse outlines preserve lexical scope and local masking", {
fixture <- readiness_fixture(c("outer <- function(hidden) { hidden_local <- 1 }",
"f <- function(print) {", " primary <- function(value) value", " pri", "}"))
fixture$document$parse_data <- NULL
text_document_completion(fixture$server, 1L, readiness_params(fixture, 3L, 5L))
items <- fixture$server$replies[[1L]]$result$items
print <- Filter(function(item) identical(item$label, "print"), items)
expect_length(print, 1L)
expect_identical(print[[1L]]$kind, CompletionItemKind$Field)
expect_true("primary" %in% vapply(items, `[[`, "", "label"))
fixture$document$set_content(2L, c("f <- function(`print`) {", " pri", "}"))
text_document_completion(fixture$server, 2L, readiness_params(fixture, 1L, 5L))
print <- Filter(function(item) item$label %in% c("print", "`print`"), fixture$server$replies[[2L]]$result$items)
expect_length(print, 1L)
expect_identical(print[[1L]]$kind, CompletionItemKind$Field)
fixture$document$set_content(3L, c("outer <- function(hidden) { hidden_local <- 1 }",
"f <- function(print) {", " primary <- function(value) value", " pri", "}"))
items <- basic_name_completion_reply(2L, fixture$workspace, fixture$document,
list(row = 3L, col = 2L), list())
expect_null(items)
fixture$document$set_content(4L, c("outer <- function(hidden) { hidden_local <- 1 }", "hidden"))
expect_null(basic_name_completion_reply(3L, fixture$workspace, fixture$document,
list(row = 1L, col = 6L), list()))
})
test_that("uncertain and oversized outlines wait for the full current parse", {
fixture <- readiness_fixture("pri")
for (content in list(c("hello <- function() {", "pri"),
c("with(data, {", "pri", "})"), c(paste0("#", strrep("x", 1024^2)), "pri"))) {
fixture$document$set_content(2L, content)
row <- match("pri", content) - 1L
expect_null(basic_name_completion_reply(1L, fixture$workspace, fixture$document,
list(row = row, col = 3L), list()))
}
})
test_that("preparse completion leaves contextual and unmatched names to the current parse", {
fixture <- readiness_fixture("pri")
for (line in c("value <- pri", "base::pri", "object$pri", "print(pri)", "# pri", '"pri"', "my_local_name")) {
fixture$document$set_content(2L, line)
expect_null(basic_name_completion_reply(1L, fixture$workspace, fixture$document,
list(row = 0L, col = nchar(line)), list()))
}
for (prefix in c("object$", "print(")) {
fixture$document$set_content(2L, c(prefix, "pri"))
expect_null(basic_name_completion_reply(1L, fixture$workspace, fixture$document,
list(row = 1L, col = 3L), list()))
}
fixture$document$set_content(3L, c("print <- function(local_arg) local_arg", "print", "print(1)"))
parsed <- parse_document(fixture$uri, fixture$document$content, include_xml = FALSE)
parsed$version <- fixture$document$version
fixture$workspace$update_parse_data(fixture$uri, parsed)
text_document_completion(fixture$server, 1L, readiness_params(fixture, 1L, 5L))
item <- Filter(function(item) identical(item$label, "print"), fixture$server$replies[[1L]]$result$items)[[1L]]
expect_identical(item$data$package, WORKSPACE)
text_document_signature_help(fixture$server, 2L, readiness_params(fixture, 2L, 6L))
expect_match(fixture$server$replies[[2L]]$result$signatures[[1L]]$label, "local_arg", fixed = TRUE)
literate <- Document$new(sub("\\.R$", ".Rmd", fixture$uri), "rmd", 1L, c("pri", "```{r}", "\tpri", "```"))
expect_null(basic_name_completion_reply(3L, fixture$workspace, literate, list(row = 0L, col = 3L), list()))
expect_true(basic_name_completion_reply(4L, fixture$workspace, literate, list(row = 2L, col = 4L), list())$result$isIncomplete)
})
test_that("verified S7 constructors use member readiness independently of S3 catalogs", {
skip_if_not_installed("S7")
snapshot <- member_prepare_package("S7")
lines <- c("library(S7)", "Dog <- new_class('Dog', properties = list(age = class_numeric))", "Dog(age = )")
fixture <- readiness_fixture(lines)
fixture$document$requested_packages <- list(packages = "S7", namespace_packages = character())
expect_null(fixture$workspace$s3_metadata$catalog("S7"))
point <- list(row = 2L, col = 10L)
expect_true(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, point))
text_document_signature_help(fixture$server, 1L, readiness_params(fixture, 2L, 10L))
expect_length(fixture$server$replies, 0L)
expect_identical(fixture$server$pending_replies$get(fixture$uri)$`textDocument/signatureHelp`$size(), 1L)
fixture$workspace$member_metadata$set("S7", snapshot)
expect_false(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, point))
drained <- drain_pending_replies(fixture$server, fixture$uri, fixture$document$version)
expect_identical(drained$processed, 1L)
expect_length(fixture$server$replies, 1L)
expect_identical(fixture$server$replies[[1L]]$result$signatures[[1L]]$label, "Dog(age = integer(0))")
expect_identical(fixture$server$pending_replies$get(fixture$uri)$`textDocument/signatureHelp`$size(), 0L)
fixture$workspace$member_metadata$remove("S7")
expect_true(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, point))
masked <- readiness_fixture(c("library(S7)", "library(pending)", lines[2:3]))
masked$workspace$member_metadata$set("S7", snapshot)
masked$document$requested_packages <- list(packages = c("S7", "pending"), namespace_packages = character())
expect_true(s3_metadata_waiting(masked$server, masked$uri, masked$document, list(row = 3L, col = 10L)))
})
test_that("cached but unloaded namespaces still preserve pending masking", {
fixture <- readiness_fixture(c("library(masking)", "print()", "masking::print()"))
fixture$document$requested_packages <- list(packages = "masking", namespace_packages = "base")
fixture$workspace$namespaces$set("masking", list(exists_funct = function(...) stop("loaded a cold namespace")))
expect_true(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, list(row = 1L, col = 6L)))
expect_true(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, list(row = 2L, col = 15L)))
})
test_that("generic providers do not wait for member-completion model preparation", {
fixture <- readiness_fixture("print()")
server <- fixture$server
server$resolve_task_manager <- readiness_task_manager()
server$member_task_manager <- readiness_task_manager()
prepare_calls <- 0L
testthat::local_mocked_bindings(member_prepare_package = function(...) {
prepare_calls <<- prepare_calls + 1L
list(schema = 1L, roots = list(), namespace_roots = list(), generation = "fixture")
}, .package = "languageserver")
task <- resolve_task(server, fixture$uri, fixture$document, character(), namespace_packages = c("base", "pending"))
server$resolve_task_manager$add_task(fixture$uri, task)
expect_true(server$member_task_manager$has(fixture$uri))
member_task <- server$member_task_manager$tasks$get(fixture$uri)
expect_true(fixture$workspace$index$indexing_status()$done)
text_document_signature_help(server, 1L, readiness_params(fixture, 0L, 6L))
text_document_hover(server, 2L, readiness_params(fixture, 0L, 2L))
expect_length(server$replies, 2L)
private <- task$.__enclos_env__$private
expect_false(private$args$prepare)
result <- do.call(private$target, private$args)
expect_identical(prepare_calls, 0L)
server$resolve_task_manager$cancel(fixture$uri)
private$callback(result)
expect_true(server$member_task_manager$has(fixture$uri))
expect_identical(server$member_task_manager$tasks$get(fixture$uri), member_task)
expect_length(server$replies, 2L)
replies <- stats::setNames(server$replies, vapply(server$replies, function(reply) as.character(reply$id), ""))
expect_match(replies$`1`$result$signatures[[1L]]$label, "print(x", fixed = TRUE)
expect_match(paste(replies$`2`$result$contents, collapse = " "), "print", fixed = TRUE)
model <- server$member_task_manager$tasks$get(fixture$uri)$.__enclos_env__$private
expect_true(model$args$prepare)
expect_false(model$args$prepare_s3)
resolve_task(server, fixture$uri, fixture$document, character(), namespace_packages = "base")
expect_true(server$member_task_manager$has(fixture$uri))
expect_false(identical(server$member_task_manager$tasks$get(fixture$uri), member_task))
resolve_task(server, fixture$uri, fixture$document, character(), namespace_packages = character())
expect_false(server$member_task_manager$has(fixture$uri))
})
test_that("member models finish independently of pending and failed S3 resolution", {
testthat::local_mocked_bindings(member_prepare_package = function(...) {
list(schema = 1L, roots = list(), namespace_roots = list(), generation = "fixture")
}, .package = "languageserver")
for (failed in c(FALSE, TRUE)) {
fixture <- readiness_fixture("print()")
server <- fixture$server
server$resolve_task_manager <- readiness_task_manager()
server$member_task_manager <- readiness_task_manager()
task <- resolve_task(server, fixture$uri, fixture$document, character(), namespace_packages = "pending")
server$resolve_task_manager$add_task(fixture$uri, task)
member <- server$member_task_manager$tasks$get(fixture$uri)$.__enclos_env__$private
expect_false(member$args$prepare_s3)
if (failed) task$.__enclos_env__$private$error(simpleError("S3 preparation timed out"))
member$callback(do.call(member$target, member$args))
expect_true(server$resolve_task_manager$has(fixture$uri))
expect_identical(fixture$workspace$member_metadata$catalog("pending")$generation, "fixture")
text_document_signature_help(server, 1L, readiness_params(fixture, 0L, 6L))
text_document_hover(server, 2L, readiness_params(fixture, 0L, 2L))
expect_length(server$replies, 2L)
expect_match(server$replies[[1L]]$result$signatures[[1L]]$label, "print(x", fixed = TRUE)
}
})
test_that("resolve completion wakes requests even if result application fails or is stale", {
fixture <- readiness_fixture("print()")
server <- fixture$server
queued <- character()
server$queue_pending_replies <- function(uri) queued <<- c(queued, uri)
load <- fixture$workspace$load_packages
unlockBinding("load_packages", fixture$workspace)
fixture$workspace$load_packages <- function(...) stop("cannot apply package metadata")
withr::defer(fixture$workspace$load_packages <- load)
expect_error(resolve_callback(server, fixture$uri, 1L, startup_packages), "cannot apply package metadata")
expect_identical(queued, fixture$uri)
queued <- character()
fixture$document$version <- 2L
expect_null(resolve_callback(server, fixture$uri, 1L, startup_packages))
expect_identical(queued, fixture$uri)
})
test_that("ordinary providers respond while unrelated package metadata is pending", {
fixture <- readiness_fixture(c("base::findInterval(1, c(0, 2))", "findInterval(1, c(0, 2))",
"local_fn <- function(value = 1) value", "local_fn(1)"))
for (row in 0:1) {
col <- if (row == 0L) 19L else 13L
params <- readiness_params(fixture, row, col)
text_document_signature_help(fixture$server, row + 1L, params)
expect_match(tail(fixture$server$replies, 1L)[[1L]]$result$signatures[[1L]]$label, "findInterval(x, vec", fixed = TRUE)
params$position$character <- if (row == 0L) 12L else 5L
text_document_hover(fixture$server, row + 3L, params)
expect_match(tail(fixture$server$replies, 1L)[[1L]]$result$contents[[1L]], "findInterval", fixed = TRUE)
params$position$character <- col
text_document_completion(fixture$server, row + 5L, params)
items <- tail(fixture$server$replies, 1L)[[1L]]$result$items
expect_true("vec" %in% vapply(items, `[[`, "", "label"))
}
text_document_signature_help(fixture$server, 7L, readiness_params(fixture, 3L, 9L))
expect_match(tail(fixture$server$replies, 1L)[[1L]]$result$signatures[[1L]]$label, "local_fn(value", fixed = TRUE)
expect_length(fixture$server$replies, 7L)
expect_true(all(vapply(fixture$server$pending_replies$get(fixture$uri), function(queue) queue$size() == 0L, logical(1L))))
})
test_that("basic providers remain available through partially accepted discovery transfers", {
values <- list(index_mode = "full", index_persistent_cache = FALSE,
index_batch_size = 20L, index_time_budget_ms = Inf)
old <- stats::setNames(lapply(names(values), lsp_settings$get), names(values))
withr::defer(for (name in names(old)) lsp_settings$set(name, old[[name]]))
for (name in names(values)) lsp_settings$set(name, values[[name]])
fixture <- readiness_fixture(c("print(1)", "pri"))
fixture$workspace$s3_metadata <- S3MetadataCache$new()
paths <- file.path(fixture$workspace$root, sprintf("unrelated-%03d.R", seq_len(80L)))
for (path in paths) writeLines("unrelated <- function(value) value", path)
manager <- readiness_task_manager()
index <- fixture$workspace$index
index$attach_worker(manager)
request <- function() {
fixture$server$replies <- list()
text_document_completion(fixture$server, 1L, readiness_params(fixture, 1L, 3L))
text_document_signature_help(fixture$server, 2L, readiness_params(fixture, 0L, 6L))
text_document_hover(fixture$server, 3L, readiness_params(fixture, 0L, 2L))
expect_length(fixture$server$replies, 3L)
replies <- stats::setNames(fixture$server$replies,
vapply(fixture$server$replies, function(reply) as.character(reply$id), character(1L)))
expect_true("print" %in% vapply(replies$`1`$result$items, `[[`, character(1L), "label"))
expect_match(replies$`2`$result$signatures[[1L]]$label, "print(x", fixed = TRUE)
expect_match(replies$`3`$result$contents[[1L]], "print", fixed = TRUE)
expect_true(all(vapply(fixture$server$pending_replies$get(fixture$uri),
function(queue) queue$size() == 0L, logical(1L))))
}
request()
index$discover()
index$process_batch()
request()
task <- tail(manager$tasks$values(), 1L)[[1L]]$.__enclos_env__$private
withr::defer(index_worker_release(task$args$key))
result <- do.call(index_worker_discover, task$args)
expect_gt(length(result$files), 20L)
task$callback(result)
request()
index$process_batch()
expect_true(index$discovering)
expect_lt(index$files$size(), length(result$files))
request()
for (i in seq_len(4L)) index$process_batch()
expect_false(index$discovering)
expect_false(index$complete())
request()
})
test_that("queued ordinary requests drain independently of S3 metadata waits", {
fixture <- readiness_fixture(c("base::findInterval(1, c(0, 2))", "pending::new_generic(1)"))
server <- fixture$server
queues <- server$pending_replies$get(fixture$uri)
queues$`textDocument/signatureHelp`$push(list(id = 1L, version = 1L,
params = readiness_params(fixture, 0L, 19L)))
queues$`textDocument/hover`$push(list(id = 2L, version = 1L,
params = readiness_params(fixture, 1L, 12L)))
expect_true(s3_metadata_waiting(server, fixture$uri, fixture$document, list(row = 1L, col = 12L), hover = TRUE))
result <- drain_pending_replies(server, fixture$uri, 1L)
expect_identical(result$processed, 1L)
expect_identical(queues$`textDocument/signatureHelp`$size(), 0L)
expect_identical(queues$`textDocument/hover`$size(), 1L)
expect_length(server$replies, 1L)
server$resolve_task_manager$has <- function(...) FALSE
result <- drain_pending_replies(server, fixture$uri, 1L)
expect_identical(result$processed, 1L)
expect_length(server$replies, 2L)
})
test_that("queued requests inside special syntax do not wait for S3 metadata", {
cases <- c(
"sample_result <- dt[, lapply(.SD, function(<cursor>))]",
"lapply(.SD, function(<cursor>) NULL)",
"if (<cursor>TRUE) NULL",
"for (<cursor>x in 1:2) NULL",
"while (<cursor>TRUE) NULL"
)
for (marked in cases) {
col <- regexpr("<cursor>", marked, fixed = TRUE)[[1L]] - 1L
fixture <- readiness_fixture(sub("<cursor>", "", marked, fixed = TRUE))
point <- list(row = 0L, col = col)
expect_null(s3_call_location(fixture$document, point), info = marked)
expect_false(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, point), info = marked)
queues <- fixture$server$pending_replies$get(fixture$uri)
for (i in seq_along(queues)) {
queues[[i]]$push(list(id = i, version = 1L, params = readiness_params(fixture, 0L, col)))
}
expect_identical(drain_pending_replies(fixture$server, fixture$uri, 1L)$processed, 3L, info = marked)
expect_length(fixture$server$replies, 3L)
expect_true(all(vapply(fixture$server$replies, function(reply) is.null(reply$error), logical(1L))), info = marked)
}
fixture <- readiness_fixture("sample_result <- dt[, lapply(.SD, function() NULL)]")
point <- list(row = 0L, col = nchar("sample_result <- dt[, lapply(.SD, funct"))
expect_null(s3_call_location(fixture$document, point, hover = TRUE))
expect_false(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, point, hover = TRUE))
point$col <- nchar("sample_result <- dt[, lapply(")
expect_identical(s3_call_location(fixture$document, point)$call$token, "lapply")
})
test_that("queued readiness errors return an error and do not block later requests", {
fixture <- readiness_fixture("print()")
server <- fixture$server
queues <- server$pending_replies$get(fixture$uri)
completion <- queues$`textDocument/completion`
completion$push(list(id = 1L, version = 1L, params = readiness_params(fixture, 0L, 1L)))
completion$push(list(id = 2L, version = 1L, params = readiness_params(fixture, 0L, 2L)))
server$request_handlers$`textDocument/completion` <- function(self, id, params) {
self$deliver(Response$new(id, result = "ok"))
}
testthat::local_mocked_bindings(
index_context_waiting = function(...) FALSE,
member_metadata_waiting = function(...) FALSE,
s3_metadata_waiting = function(self, uri, document, point, ...) {
if (point$col == 1L) stop("readiness failed")
FALSE
}, .package = "languageserver")
result <- drain_pending_replies(server, fixture$uri, 1L, max_replies = 1L)
expect_identical(result$processed, 1L)
expect_true(result$ready)
expect_identical(server$replies[[1L]]$id, 1L)
expect_identical(server$replies[[1L]]$error$code, -32603)
expect_match(server$replies[[1L]]$error$message, "readiness failed", fixed = TRUE)
expect_identical(completion$size(), 1L)
expect_identical(drain_pending_replies(server, fixture$uri, 1L)$processed, 1L)
expect_identical(server$replies[[2L]]$id, 2L)
expect_identical(server$replies[[2L]]$result, "ok")
expect_identical(completion$size(), 0L)
})
test_that("queued signatures use the enclosing call while S3 metadata is pending", {
fixture <- readiness_fixture(c('masking::new_generic(data.frame(x = 1), r"(first',
'base::findInterval(1)")'))
fixture$document$requested_packages <- list(packages = character(), namespace_packages = c("base", "masking"))
server <- fixture$server
col <- nchar("base::findInterval(1")
text_document_signature_help(server, 1L, readiness_params(fixture, 1L, col))
queue <- server$pending_replies$get(fixture$uri)$`textDocument/signatureHelp`
expect_length(server$replies, 0L)
expect_identical(queue$size(), 1L)
for (i in seq_len(3L)) {
result <- drain_pending_replies(server, fixture$uri, 1L, max_replies = 3L)
expect_identical(result$processed, 0L)
expect_false(result$ready)
expect_identical(queue$size(), 1L)
expect_identical(queue$peek()$id, 1L)
expect_length(server$replies, 0L)
}
catalog <- readiness_masking_catalog()
catalog$callables <- "new_generic"
generic <- catalog$functions$findInterval
generic$name <- generic$generic$name <- "new_generic"
catalog$functions <- list(new_generic = generic)
method <- catalog$methods[[1L]]
method$name <- "new_generic.data.frame"
method$generic <- "new_generic"
catalog$methods <- list("masking::new_generic.data.frame" = method)
fixture$workspace$s3_metadata$set("masking", catalog)
result <- drain_pending_replies(server, fixture$uri, 1L)
expect_identical(result$processed, 1L)
expect_identical(queue$size(), 0L)
expect_length(server$replies, 1L)
expect_match(server$replies[[1L]]$result$signatures[[1L]]$label, "columns = NULL", fixed = TRUE)
})
test_that("unknown package generics still wait for their first catalog", {
fixture <- readiness_fixture(c("new_generic(1)", "pending::new_generic(1)",
"f <- function() base::findInterval(1, c(0, 2))"))
expect_true(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, list(row = 0L, col = 12L)))
expect_true(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, list(row = 1L, col = 21L)))
location <- s3_call_location(fixture$document, list(row = 2L, col = 35L))
expect_false(s3_may_dispatch(fixture$workspace, fixture$document, location))
fixture$workspace$s3_metadata$set("pending", list(schema = 1L, generation = "ready",
functions = list(), objects = list(), methods = list(), dependencies = character()))
expect_false(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, list(row = 0L, col = 12L)))
})
test_that("ordinary calls inside functions remain responsive without bypassing shadowed calls", {
fixture <- readiness_fixture(c("f <- function() {", " findInterval(1, c(0, 2))", "}"))
params <- readiness_params(fixture, 1L, 15L)
expect_false(s3_metadata_waiting(fixture$server, fixture$uri, fixture$document, list(row = 1L, col = 15L)))
text_document_signature_help(fixture$server, 1L, params)
expect_match(fixture$server$replies[[1L]]$result$signatures[[1L]]$label, "findInterval", fixed = TRUE)
shadowed <- readiness_fixture("f <- function(findInterval) findInterval(1)")
expect_true(s3_metadata_waiting(shadowed$server, shadowed$uri, shadowed$document, list(row = 0L, col = 41L)))
aliased <- readiness_fixture(c("f <- function() {", " findInterval <- base::summary", " findInterval(1)", "}"))
expect_true(s3_metadata_waiting(aliased$server, aliased$uri, aliased$document, list(row = 2L, col = 15L)))
quoted <- readiness_fixture("f <- function(`findInterval`) findInterval(1)")
expect_true(s3_metadata_waiting(quoted$server, quoted$uri, quoted$document, list(row = 0L, col = 43L)))
quoted_alias <- readiness_fixture(c("f <- function() {", " `findInterval` <- base::summary", " findInterval(1)", "}"))
expect_true(s3_metadata_waiting(quoted_alias$server, quoted_alias$uri, quoted_alias$document, list(row = 2L, col = 15L)))
})
test_that("pending attached packages can mask ordinary functions with S3 generics", {
fixture <- readiness_fixture(c("library(masking)", "findInterval(data.frame(x = 1), )",
"base::findInterval(1, c(0, 2))"))
fixture$document$requested_packages <- list(packages = "masking", namespace_packages = "base")
server <- fixture$server
params <- readiness_params(fixture, 1L, nchar(fixture$document$line0(1L)) - 1L)
text_document_signature_help(server, 1L, params)
hover_params <- readiness_params(fixture, 1L, 5L)
text_document_hover(server, 2L, hover_params)
text_document_completion(server, 3L, params)
text_document_signature_help(server, 4L, readiness_params(fixture, 2L, 19L))
expect_length(server$replies, 1L)
queues <- server$pending_replies$get(fixture$uri)
expect_true(all(vapply(queues, function(queue) queue$size() == 1L, logical(1L))))
fixture$workspace$s3_metadata$set("masking", list(schema = 1L, package = "masking", generation = "failed",
functions = list(), callables = character(), methods = list(), objects = list(), error = "Previous resolution failed"))
expect_identical(drain_pending_replies(server, fixture$uri, 1L)$processed, 0L)
fixture$workspace$s3_metadata$set("masking", readiness_masking_catalog())
expect_identical(drain_pending_replies(server, fixture$uri, 1L)$processed, 3L)
replies <- stats::setNames(server$replies, vapply(server$replies, function(reply) as.character(reply$id), ""))
expect_match(replies$`1`$result$signatures[[1L]]$label, "columns = NULL", fixed = TRUE)
expect_match(paste(replies$`2`$result$contents, collapse = " "), "findInterval.data.frame", fixed = TRUE)
expect_true("columns" %in% vapply(replies$`3`$result$items, `[[`, "", "label"))
expect_match(replies$`4`$result$signatures[[1L]]$label, "vec", fixed = TRUE)
})
test_that("namespace-only and later package requests do not mask an earlier ordinary call", {
fixture <- readiness_fixture("findInterval(1, c(0, 2))")
fixture$document$requested_packages <- list(packages = character(), namespace_packages = c("base", "masking"))
params <- readiness_params(fixture, 0L, 13L)
text_document_signature_help(fixture$server, 1L, params)
expect_match(fixture$server$replies[[1L]]$result$signatures[[1L]]$label, "vec", fixed = TRUE)
fixture$workspace$s3_metadata$set("masking", readiness_masking_catalog())
text_document_signature_help(fixture$server, 2L, params)
expect_match(fixture$server$replies[[2L]]$result$signatures[[1L]]$label, "vec", fixed = TRUE)
later <- readiness_fixture(c("findInterval(1, c(0, 2))", "library(masking)"))
later$document$requested_packages <- list(packages = "masking", namespace_packages = "base")
text_document_signature_help(later$server, 1L, readiness_params(later, 0L, 13L))
expect_match(later$server$replies[[1L]]$result$signatures[[1L]]$label, "vec", fixed = TRUE)
})
test_that("repeated unqualified calls avoid individual document and summary scans", {
fixture <- readiness_package_fixture()
workspace <- fixture$workspace
for (i in seq_len(1000L)) {
readiness_peer(fixture, paste0("peer", i), paste0("fn_", i, " <- function(x) x"), full = i <= 500L)
}
expect_identical(workspace$index$files$size(), 1001L)
counts <- new.env(parent = emptyenv())
counts$documents <- counts$summaries <- counts$keys <- 0L
get_document <- workspace$documents$get
get_summary <- workspace$index$summaries$get
get_keys <- workspace$documents$keys
withr::defer({
workspace$documents$get <- get_document
workspace$index$summaries$get <- get_summary
workspace$documents$keys <- get_keys
})
workspace$documents$get <- function(...) {
counts$documents <- counts$documents + 1L
get_document(...)
}
workspace$index$summaries$get <- function(...) {
counts$summaries <- counts$summaries + 1L
get_summary(...)
}
workspace$documents$keys <- function(...) {
counts$keys <- counts$keys + 1L
get_keys(...)
}
location <- s3_call_location(fixture$document, list(row = 0L, col = 13L))
expect_false(s3_may_dispatch(workspace, fixture$document, location))
expect_gt(counts$documents, 0L)
expect_gt(counts$summaries, 0L)
counts$documents <- counts$summaries <- counts$keys <- 0L
for (i in seq_len(10L)) expect_false(s3_may_dispatch(workspace, fixture$document, location))
expect_identical(counts$documents, 0L)
expect_identical(counts$summaries, 0L)
expect_identical(counts$keys, 0L)
})
test_that("cached peer imports follow edits, indexing and workspace membership", {
fixture <- readiness_package_fixture()
workspace <- fixture$workspace
peer <- readiness_peer(fixture, "peer", "library(masking)")
disk <- readiness_peer(fixture, "disk", "library(disk_package)", full = FALSE)
packages <- function() s3_call_packages(workspace, fixture$document, c(0L, 13L))
expect_true(all(c("masking", "disk_package") %in% packages()))
document <- workspace$documents$get(peer)
document$set_content(2L, "helper <- 1")
ReadinessSyncServer$new(workspace)$text_sync(peer, document)
expect_false("masking" %in% packages())
expect_true("disk_package" %in% packages())
document$set_content(3L, "library(changed_package)")
parsed <- parse_document(peer, document$content, include_xml = FALSE)
parsed$version <- document$version
workspace$update_parse_data(peer, parsed)
expect_true("changed_package" %in% packages())
workspace$index$update_content(disk, "library(updated_disk_package)")
expect_true("updated_disk_package" %in% packages())
expect_false("disk_package" %in% packages())
replacement <- Document$new(path_to_uri(file.path(workspace$root, "R", "replacement.R")), "r", 1L,
"library(replacement_package)")
parsed <- parse_document(replacement$uri, replacement$content, include_xml = FALSE)
parsed$version <- replacement$version
replacement$update_parse_data(parsed)
workspace$documents$remove(peer)
workspace$documents$set(replacement$uri, replacement)
workspace$update_loaded_packages()
expect_true("replacement_package" %in% packages())
# Unloaded package files remain visible through their disk summaries.
expect_true("changed_package" %in% packages())
workspace$index$remove(peer)
expect_false("changed_package" %in% packages())
workspace$imported_packages <- "imported_package"
expect_true("imported_package" %in% packages())
workspace$index <- WorkspaceIndex$new(workspace$root)
expect_false("updated_disk_package" %in% packages())
workspace$documents$remove(replacement$uri)
expect_false("replacement_package" %in% packages())
})
test_that("cached peer imports preserve cursor-specific masking in the current document", {
fixture <- readiness_package_fixture()
document <- fixture$document
document$set_content(2L, c("findInterval(1, c(0, 2))", "library(masking)", "findInterval(1, c(0, 2))"))
parsed <- parse_document(fixture$uri, document$content, include_xml = FALSE)
parsed$version <- document$version
fixture$workspace$update_parse_data(fixture$uri, parsed)
expect_false("masking" %in% s3_call_packages(fixture$workspace, document, c(0L, 13L)))
expect_true("masking" %in% s3_call_packages(fixture$workspace, document, c(2L, 13L)))
expect_false("masking" %in% s3_call_packages(fixture$workspace, document, c(0L, 13L)))
})
test_that("ordinary requests do not rescan the workspace definition catalog", {
fixture <- readiness_fixture("findInterval(1, c(0, 2))")
index <- fixture$workspace$index
values <- index$summaries$values
index$summaries$values <- function(...) stop("request scanned all workspace summaries")
withr::defer(index$summaries$values <- values)
for (i in seq_len(100L)) {
uri <- path_to_uri(file.path(fixture$workspace$root, paste0(i, ".R")))
index$set_summary(list(uri = uri, sources = character(),
definitions = list(shared = list(name = "shared"))))
text_document_signature_help(fixture$server, i, readiness_params(fixture, 0L, 13L))
}
expect_length(fixture$server$replies, 100L)
expect_true(index$has_definition("shared"))
index$remove(uri)
expect_true(index$has_definition("shared"))
for (i in seq_len(99L)) index$remove(path_to_uri(file.path(fixture$workspace$root, paste0(i, ".R"))))
expect_false(index$has_definition("shared"))
})
test_that("failed parse workers settle queued requests and allow a later parse", {
fixture <- readiness_fixture("base::findInterval(1, c(0, 2))")
server <- fixture$server
document <- fixture$document
document$set_content(2L, c(document$content, "new_value <- 1"))
queues <- server$pending_replies$get(fixture$uri)
queues$`textDocument/signatureHelp`$push(list(id = 1L, version = 2L,
params = readiness_params(fixture, 0L, 19L)))
queues$`textDocument/hover`$push(list(id = 2L, version = 1L, params = list()))
queues$`textDocument/completion`$push(list(id = 3L, version = 3L, params = list()))
task <- parse_task(server, fixture$uri, document, retry = FALSE)
task$.__enclos_env__$private$error(simpleError("worker exited"))
expect_length(server$replies, 2L)
expect_identical(server$replies[[1L]]$error$code, -32800)
expect_identical(server$replies[[2L]]$error$code, -32603)
expect_match(server$replies[[2L]]$error$message, "worker exited", fixed = TRUE)
expect_identical(queues$`textDocument/completion`$size(), 1L)
text_document_signature_help(server, 4L, readiness_params(fixture, 0L, 19L))
expect_identical(tail(server$replies, 1L)[[1L]]$error$code, -32603)
queues$`textDocument/completion`$pop()
document$set_content(3L, "base::findInterval(1, c(0, 2))")
task <- parse_task(server, fixture$uri, document, retry = FALSE)
parsed <- parse_document(fixture$uri, document$content, include_xml = FALSE)
task$.__enclos_env__$private$callback(parsed)
expect_null(document$parse_failure)
text_document_signature_help(server, 5L, readiness_params(fixture, 0L, 19L))
expect_match(tail(server$replies, 1L)[[1L]]$result$signatures[[1L]]$label, "findInterval", fixed = TRUE)
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.