tests/testthat/test-package-resolution-reuse.R

package_reuse_workspace <- function(root) {
    workspace <- new.env(parent = emptyenv())
    workspace$root <- file.path(root, "workspace")
    dir.create(workspace$root, recursive = TRUE)
    workspace$documents <- collections::dict()
    workspace$index <- list(enabled = FALSE, finish_document = function(...) NULL)
    workspace$member_metadata <- MemberMetadataCache$new(16 * 1024^2)
    workspace$s3_metadata <- S3MetadataCache$new()
    workspace$startup_member_packages <- character()
    workspace$type_hierarchy_cache <- collections::dict()
    workspace$applied <- list()
    workspace$update_parse_data <- function(uri, parsed) {
        workspace$documents$get(uri)$update_parse_data(parsed)
    }
    workspace$load_packages <- function(packages) {
        workspace$applied[[length(workspace$applied) + 1L]] <- packages
    }
    workspace$update_loaded_packages <- function() NULL
    workspace
}

package_reuse_fixture <- function(members = FALSE, s3 = FALSE,
    .local_envir = parent.frame()) {
    previous <- stats::setNames(lapply(c("member_completion", "s3_dispatch"), lsp_settings$get),
        c("member_completion", "s3_dispatch"))
    withr::defer(for (key in names(previous)) lsp_settings$set(key, previous[[key]]),
        envir = .local_envir)
    withr::local_envvar(R_COVR = "false", .local_envir = .local_envir)
    lsp_settings$set("member_completion", members)
    lsp_settings$set("s3_dispatch", s3)

    state <- new.env(parent = emptyenv())
    state$processes <- list()
    state$installation <- "original-installation"
    testthat::local_mocked_bindings(detectCores = function(...) 32L,
        .package = "parallel", .env = .local_envir)
    testthat::local_mocked_bindings(
        package_resolution_installations = function(packages, ...) {
            list(key = state$installation, complete = TRUE,
                packages = unique(c(packages, "R6")))
        },
        diagnostics_callback = function(...) NULL,
        .package = "languageserver", .env = .local_envir)
    testthat::local_mocked_bindings(r_bg = function(func, args, ...) {
        process <- new.env(parent = emptyenv())
        process$args <- args
        process$ready <- FALSE
        process$killed <- 0L
        process$result <- NULL
        process$error <- NULL
        process$is_alive <- function() !process$ready && process$killed == 0L
        process$get_result <- function() {
            if (!is.null(process$error)) stop(process$error)
            process$result
        }
        process$kill <- function(...) process$killed <- process$killed + 1L
        state$processes[[length(state$processes) + 1L]] <- process
        process
    }, .package = "callr", .env = .local_envir)

    root <- withr::local_tempdir(.local_envir = .local_envir)
    workspace <- package_reuse_workspace(root)

    server <- new.env(parent = emptyenv())
    server$get_workspace <- function(...) workspace
    server$workspaces <- collections::dict()
    server$workspaces$set(path_to_uri(workspace$root), workspace)
    server$pending_replies <- collections::dict()
    server$queue_pending_replies <- function(...) NULL
    server$deliver <- function(...) NULL
    server$parse_task_manager <- list(cancel = function(...) NULL)
    server$resolve_task_manager <- SharedTaskManager$new("reuse-resolve",
        max_running_tasks = 32L, cpu_load = 1)
    if (members) server$member_task_manager <- SharedTaskManager$new("reuse-members",
        max_running_tasks = 32L, cpu_load = 1)
    withr::defer({
        server$resolve_task_manager$stop()
        if (!is.null(server$member_task_manager)) server$member_task_manager$stop()
    }, envir = .local_envir)

    list(server = server, workspace = workspace, state = state, root = root)
}

package_reuse_document <- function(fixture, name, packages = "callr",
    namespace_packages = character(), version = 1L) {
    uri <- path_to_uri(file.path(fixture$root, paste0(".vdoc.", name, ".r")))
    content <- c(paste0("library(", packages, ")"),
        if (length(namespace_packages)) paste0(namespace_packages, "::value"), "value <- 1L")
    document <- Document$new(uri, "r", version, content)
    document$did_open()
    fixture$workspace$documents$set(uri, document)
    fixture$server$pending_replies$set(uri, list())
    package_reuse_parse(fixture, document)
    document
}

package_reuse_parse <- function(fixture, document) {
    parsed <- parse_document(document$uri, document$content, include_xml = FALSE)
    parse_callback(fixture$server, document$uri, document$version, parsed, cache = FALSE)
}

package_reuse_start <- function(fixture) {
    fixture$server$resolve_task_manager$run_tasks()
    if (!is.null(fixture$server$member_task_manager)) fixture$server$member_task_manager$run_tasks()
}

package_reuse_result <- function(process) {
    args <- process$args
    packages <- unique(c(startup_packages, "R6", args$pkgs))
    members <- list()
    if (isTRUE(args$prepare)) {
        for (package in unique(c(setdiff(packages, startup_packages), args$namespace_packages))) {
            index <- member_generic_index("")
            index$package <- package
            index$identity <- list(package = package, revision = 1L)
            members[package] <- list(member_index_freeze(index))
        }
    }
    catalogs <- if (isTRUE(args$prepare_s3)) {
        names <- unique(c(packages, args$namespace_packages))
        stats::setNames(lapply(names, function(package) {
            list(schema = 1L, package = package, generation = "fixture",
                functions = list(), objects = list(), methods = list(), dependencies = character())
        }), names)
    } else {
        NULL
    }
    list(packages = packages, members = members, s3 = catalogs,
        requested = list(packages = normalize_package_request(args$pkgs),
            namespace_packages = normalize_package_request(unique(args$namespace_packages))))
}

package_reuse_finish <- function(fixture, processes = fixture$state$processes, error = NULL,
    transform = function(result, process) result) {
    for (process in processes) {
        process$result <- transform(package_reuse_result(process), process)
        process$error <- error
        process$ready <- TRUE
    }
    fixture$server$resolve_task_manager$check_tasks()
    if (!is.null(fixture$server$member_task_manager)) fixture$server$member_task_manager$check_tasks()
}

package_reuse_close <- function(fixture, document) {
    text_document_did_close(fixture$server, list(textDocument = list(uri = document$uri)))
}

test_that("Equivalent fresh documents share resolution even with metadata features disabled", {
    fixture <- package_reuse_fixture()
    documents <- lapply(seq_len(12L), function(i) package_reuse_document(fixture, i))
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 1L)
    expect_false(fixture$state$processes[[1L]]$args$prepare)
    expect_false(fixture$state$processes[[1L]]$args$prepare_s3)
    package_reuse_finish(fixture)
    expected <- c(startup_packages, "R6", "callr")
    for (document in documents) {
        expect_identical(document$loaded_packages, expected)
        expect_false(fixture$server$resolve_task_manager$has(document$uri))
    }
    cached <- package_reuse_document(fixture, "cached")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 1L)
    expect_identical(cached$loaded_packages, expected)
})

test_that("Split member and S3 workers each share across fresh documents", {
    fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
    documents <- lapply(seq_len(8L), function(i) {
        package_reuse_document(fixture, i, namespace_packages = "processx")
    })
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 2L)
    expect_identical(vapply(fixture$state$processes, function(process) process$args$prepare, logical(1L)),
        c(FALSE, TRUE))
    expect_identical(vapply(fixture$state$processes, function(process) process$args$prepare_s3, logical(1L)),
        c(TRUE, FALSE))
    package_reuse_finish(fixture)
    for (document in documents) {
        expect_true("R6" %in% document$loaded_packages)
        expect_false(fixture$server$resolve_task_manager$has(document$uri))
        expect_false(fixture$server$member_task_manager$has(document$uri))
    }
    expect_false(is.null(fixture$workspace$member_metadata$catalog("processx")))
    expect_false(is.null(fixture$workspace$s3_metadata$catalog("processx")))
    cached <- package_reuse_document(fixture, "cached", namespace_packages = "processx")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 2L)
    expect_true("R6" %in% cached$loaded_packages)
})

test_that("Attachment order and namespace requests keep distinct resolution jobs", {
    fixture <- package_reuse_fixture()
    first <- package_reuse_document(fixture, "first", c("callr", "ps"))
    second <- package_reuse_document(fixture, "second", c("ps", "callr"))
    third <- package_reuse_document(fixture, "third", c("callr", "ps"), "processx")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 3L)
    package_reuse_finish(fixture)
    expect_identical(tail(first$loaded_packages, 2L), c("callr", "ps"))
    expect_identical(tail(second$loaded_packages, 2L), c("ps", "callr"))
    expect_identical(third$requested_packages$namespace_packages, "processx")
})

test_that("Closing one subscriber preserves shared work and closing the last cancels it", {
    for (running in c(FALSE, TRUE)) {
        fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
        first <- package_reuse_document(fixture, "first")
        second <- package_reuse_document(fixture, "second")
        if (running) package_reuse_start(fixture)
        package_reuse_close(fixture, first)
        expect_false(fixture$server$resolve_task_manager$has(first$uri))
        expect_false(fixture$server$member_task_manager$has(first$uri))
        expect_true(fixture$server$resolve_task_manager$has(second$uri))
        expect_true(fixture$server$member_task_manager$has(second$uri))
        expect_true(all(vapply(fixture$state$processes, function(process) process$killed == 0L, logical(1L))))
        package_reuse_close(fixture, second)
        expect_false(fixture$server$resolve_task_manager$has(second$uri))
        expect_false(fixture$server$member_task_manager$has(second$uri))
        if (running) {
            expect_true(all(vapply(fixture$state$processes, function(process) process$killed == 1L, logical(1L))))
        } else {
            package_reuse_start(fixture)
            expect_length(fixture$state$processes, 0L)
        }
    }
})

test_that("Old shared replies cannot update changed or reopened documents", {
    fixture <- package_reuse_fixture()
    changed <- package_reuse_document(fixture, "changed")
    reopened <- package_reuse_document(fixture, "reopened")
    peer <- package_reuse_document(fixture, "peer")
    package_reuse_start(fixture)
    old_processes <- fixture$state$processes
    changed$set_content(2L, c("library(ps)", "value <- 2L"))
    package_reuse_parse(fixture, changed)
    package_reuse_close(fixture, reopened)
    replacement <- package_reuse_document(fixture, "reopened", "ps")
    package_reuse_finish(fixture, old_processes)
    expect_identical(changed$loaded_packages, "ps")
    expect_identical(replacement$loaded_packages, "ps")
    expect_identical(peer$loaded_packages, c(startup_packages, "R6", "callr"))
    expect_identical(reopened$loaded_packages, "callr")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 2L)
    package_reuse_finish(fixture, fixture$state$processes[2L])
    expect_identical(changed$loaded_packages, c(startup_packages, "R6", "ps"))
    expect_identical(replacement$loaded_packages, changed$loaded_packages)
})

test_that("Completed results invalidate on package installations and library paths", {
    fixture <- package_reuse_fixture()
    package_reuse_document(fixture, "original")
    package_reuse_start(fixture)
    package_reuse_finish(fixture)
    fixture$state$installation <- "reinstalled-package"
    package_reuse_document(fixture, "reinstalled")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 2L)
    package_reuse_finish(fixture, fixture$state$processes[2L])
    library <- withr::local_tempdir()
    withr::local_libpaths(c(library, .libPaths()))
    package_reuse_document(fixture, "library")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 3L)
    expect_identical(fixture$state$processes[[3L]]$args$lib_paths, .libPaths())
})

test_that("Failed shared resolutions are retried by the next fresh document", {
    fixture <- package_reuse_fixture()
    first <- package_reuse_document(fixture, "first")
    second <- package_reuse_document(fixture, "second")
    package_reuse_start(fixture)
    package_reuse_finish(fixture, error = simpleError("fixture resolution failed"))
    expect_false(fixture$server$resolve_task_manager$has(first$uri))
    expect_false(fixture$server$resolve_task_manager$has(second$uri))
    retry <- package_reuse_document(fixture, "retry")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 2L)
    package_reuse_finish(fixture, fixture$state$processes[2L])
    expect_true("R6" %in% retry$loaded_packages)
})

test_that("Saving a document refreshes completed member and S3 resolution", {
    fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
    document <- package_reuse_document(fixture, "saved")
    package_reuse_start(fixture)
    package_reuse_finish(fixture)
    expect_length(fixture$state$processes, 2L)
    document$member_refresh <- TRUE
    package_reuse_parse(fixture, document)
    expect_false(document$member_refresh)
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 4L)
    package_reuse_finish(fixture, fixture$state$processes[3:4])
    expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
})

test_that("Repeated running member refreshes schedule one fresh successor", {
    fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
    document <- package_reuse_document(fixture, "refresh")
    package_reuse_start(fixture)
    original <- fixture$server$member_task_manager$get_task(document$uri)
    original_processes <- fixture$state$processes
    for (i in seq_len(5L)) {
        document$set_content(i + 1L, c("library(callr)", paste0("value <- ", i)))
        document$member_refresh <- TRUE
        package_reuse_parse(fixture, document)
        expect_identical(fixture$server$member_task_manager$get_task(document$uri), original)
    }
    expect_true(original$context$refresh_pending)
    expect_true(all(vapply(original_processes, function(process) process$killed == 0L, logical(1L))))
    package_reuse_finish(fixture, original_processes)
    successor <- fixture$server$member_task_manager$get_task(document$uri)
    expect_false(is.null(successor))
    expect_false(identical(successor, original))
    expect_null(successor$execution_started_at)
    package_reuse_start(fixture)
    expect_identical(sum(vapply(fixture$state$processes, function(process) process$args$prepare, logical(1L))), 2L)
    pending <- Filter(function(process) !process$ready, fixture$state$processes)
    package_reuse_finish(fixture, pending)
    expect_false(fixture$server$member_task_manager$has(document$uri))
})

test_that("Completed shared member catalogs populate another workspace", {
    fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
    package_reuse_document(fixture, "first", namespace_packages = "processx")
    package_reuse_start(fixture)
    package_reuse_finish(fixture)
    other <- fixture
    other$root <- file.path(fixture$root, "other")
    other$workspace <- package_reuse_workspace(other$root)
    other_uri <- path_to_uri(other$root)
    fixture$server$get_workspace <- function(uri) {
        if (startsWith(uri, other_uri)) other$workspace else fixture$workspace
    }
    document <- package_reuse_document(other, "second", namespace_packages = "processx")
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 2L)
    for (package in c("R6", "callr", "processx")) {
        expect_false(is.null(other$workspace$member_metadata$catalog(package)))
        expect_false(is.null(other$workspace$s3_metadata$catalog(package)))
    }
    expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
})

test_that("Failed and incomplete metadata results do not satisfy later fresh documents", {
    for (failure in c("missing_member", "failed_member", "partial_member", "failed_s3", "missing_s3")) {
        fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
        package_reuse_document(fixture, "first")
        package_reuse_start(fixture)
        package_reuse_finish(fixture, transform = function(result, process) {
            if (isTRUE(process$args$prepare)) {
                if (failure == "missing_member") result$members$callr <- NULL
                if (failure == "failed_member") result$members$callr$error <- "fixture metadata failure"
                if (failure == "partial_member") result$members$callr$dataset_only <- TRUE
            }
            if (isTRUE(process$args$prepare_s3)) {
                if (failure == "failed_s3") result$s3$callr$error <- "fixture S3 failure"
                if (failure == "missing_s3") result$s3$callr <- NULL
            }
            result
        })
        package_reuse_document(fixture, "retry")
        package_reuse_start(fixture)
        expect_equal(length(fixture$state$processes), 3L, info = failure)
        expect_identical(fixture$state$processes[[3L]]$args$prepare,
            failure %in% c("missing_member", "failed_member", "partial_member"), info = failure)
        package_reuse_finish(fixture, fixture$state$processes[3L])
    }
})

test_that("Shared jobs retain provider readiness for every subscribing document", {
    fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
    documents <- lapply(c("first", "second"), function(name) {
        document <- package_reuse_document(fixture, name, namespace_packages = "processx")
        document$set_content(2L, c("library(callr)", "processx::value$field", "value <- 1L"))
        package_reuse_parse(fixture, document)
        document
    })
    point <- list(row = 1L, col = nchar("processx::value$"))
    for (document in documents) {
        expect_true(s3_metadata_waiting(fixture$server, document$uri, document))
        expect_true(member_metadata_waiting(fixture$server, document$uri, document, point))
    }
    package_reuse_start(fixture)
    package_reuse_finish(fixture)
    for (document in documents) {
        expect_false(s3_metadata_waiting(fixture$server, document$uri, document))
        expect_false(member_metadata_waiting(fixture$server, document$uri, document, point))
    }
})

test_that("Disabling metadata during resolution restarts shared attachment resolution", {
    withr::local_options(languageserver.member_completion = NULL, languageserver.s3_dispatch = NULL)
    testthat::local_mocked_bindings(
        backend_settings_changed = function(...) NULL,
        sync_formatting_capabilities = function(...) NULL,
        .package = "languageserver")
    fixture <- package_reuse_fixture(members = TRUE, s3 = TRUE)
    documents <- lapply(c("first", "second"), function(name) package_reuse_document(fixture, name))
    package_reuse_start(fixture)
    original <- fixture$state$processes
    expect_length(original, 2L)
    workspace_did_change_configuration(fixture$server,
        list(settings = list(r = list(lsp = list(member_completion = FALSE, s3_dispatch = FALSE)))))
    expect_false(lsp_settings$get("member_completion"))
    expect_false(lsp_settings$get("s3_dispatch"))
    expect_true(all(vapply(original, function(process) process$killed == 1L, logical(1L))))
    for (document in documents) {
        expect_false(fixture$server$member_task_manager$has(document$uri))
        expect_true(fixture$server$resolve_task_manager$has(document$uri))
        expect_false(document$member_refresh)
    }
    package_reuse_finish(fixture, original)
    expect_length(fixture$workspace$applied, 0L)
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 3L)
    process <- fixture$state$processes[[3L]]
    expect_false(process$args$prepare)
    expect_false(process$args$prepare_s3)
    package_reuse_finish(fixture, list(process))
    for (document in documents) {
        expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
        package_reuse_parse(fixture, document)
        expect_false(fixture$server$resolve_task_manager$has(document$uri))
    }
})

test_that("Enabling member completion prepares existing documents with S3 disabled", {
    withr::local_options(languageserver.member_completion = NULL, languageserver.s3_dispatch = NULL)
    testthat::local_mocked_bindings(
        backend_settings_changed = function(...) NULL,
        sync_formatting_capabilities = function(...) NULL,
        .package = "languageserver")
    fixture <- package_reuse_fixture()
    fixture$server$member_task_manager <- SharedTaskManager$new("reuse-enabled-members",
        max_running_tasks = 32L, cpu_load = 1)
    document <- package_reuse_document(fixture, "existing", namespace_packages = "processx")
    package_reuse_start(fixture)
    package_reuse_finish(fixture)
    expect_length(fixture$state$processes, 1L)
    expect_null(fixture$workspace$member_metadata$catalog("processx"))
    workspace_did_change_configuration(fixture$server,
        list(settings = list(member_completion = TRUE)))
    expect_true(lsp_settings$get("member_completion"))
    expect_false(lsp_settings$get("s3_dispatch"))
    expect_true(fixture$server$member_task_manager$has(document$uri))
    expect_false(document$member_refresh)
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 3L)
    expect_true(fixture$state$processes[[3L]]$args$prepare)
    expect_false(fixture$state$processes[[3L]]$args$prepare_s3)
    package_reuse_finish(fixture, fixture$state$processes[2:3])
    expect_false(is.null(fixture$workspace$member_metadata$catalog("processx")))
    expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
})

package_reuse_pending_configuration <- function(initial_enabled, parse_state) {
    fixture <- package_reuse_fixture(members = initial_enabled, s3 = initial_enabled)
    if (is.null(fixture$server$member_task_manager)) {
        fixture$server$member_task_manager <- SharedTaskManager$new("reuse-pending-members",
            max_running_tasks = 32L, cpu_load = 1)
    }
    document <- package_reuse_document(fixture, "pending")
    original_content <- document$content
    original_parsed <- document$parse_data
    package_reuse_start(fixture)
    original_processes <- fixture$state$processes
    expect_equal(length(original_processes), if (initial_enabled) 2L else 1L)

    if (parse_state == "pending") {
        document$set_content(2L, c("library(callr)", "value <- 2L"))
        expect_false(identical(document$version, document$parse_data$version))
    } else if (parse_state == "error") {
        document$set_content(2L, c("library(callr)", "value <- )"))
        package_reuse_parse(fixture, document)
        expect_true(document$parse_data$parse_error)
        expect_identical(document$requested_packages$packages, "callr")
    } else {
        if (parse_state == "missing_null_version") document$version <- NULL
        document$parse_data <- NULL
    }

    enabled <- !initial_enabled
    workspace_did_change_configuration(fixture$server,
        list(settings = list(member_completion = enabled, s3_dispatch = enabled)))
    expect_identical(lsp_settings$get("member_completion"), enabled)
    expect_identical(lsp_settings$get("s3_dispatch"), enabled)
    expect_identical(document$requested_packages$packages, "callr")
    expect_true(document$member_refresh)
    expect_equal(length(fixture$state$processes), length(original_processes))

    if (parse_state == "pending") {
        parse_callback(fixture$server, document$uri, 1L, original_parsed,
            source_content = original_content, cache = FALSE)
        expect_false(identical(document$version, document$parse_data$version))
    } else if (parse_state == "error") {
        package_reuse_parse(fixture, document)
        expect_true(document$parse_data$parse_error)
    } else {
        parse_callback(fixture$server, document$uri, document$version, NULL, cache = FALSE)
        expect_null(document$parse_data)
    }
    expect_true(document$member_refresh)
    package_reuse_finish(fixture, original_processes)
    expect_length(fixture$workspace$applied, 0L)
    expect_identical(document$loaded_packages, "callr")
    expect_true(document$member_refresh)

    if (parse_state == "error") {
        document$set_content(3L, c("library(callr)", "value <- 3L"))
    }
    package_reuse_parse(fixture, document)
    expect_identical(document$requested_packages$packages, "callr")
    expect_false(document$member_refresh)
    expect_true(fixture$server$resolve_task_manager$has(document$uri))
    expect_identical(fixture$server$member_task_manager$has(document$uri), enabled)
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 3L)
    replacement <- Filter(function(process) !process$ready, fixture$state$processes)
    expect_identical(vapply(replacement, function(process) process$args$prepare, logical(1L)),
        if (enabled) c(FALSE, TRUE) else FALSE)
    expect_identical(vapply(replacement, function(process) process$args$prepare_s3, logical(1L)),
        if (enabled) c(TRUE, FALSE) else FALSE)

    task <- fixture$server$resolve_task_manager$get_task(document$uri)
    package_reuse_parse(fixture, document)
    expect_identical(fixture$server$resolve_task_manager$get_task(document$uri), task)
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 3L)
    package_reuse_finish(fixture, replacement)
    expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
    expect_identical(is.null(fixture$workspace$member_metadata$catalog("callr")), !enabled)
    expect_identical(is.null(fixture$workspace$s3_metadata$catalog("callr")), !enabled)
    package_reuse_parse(fixture, document)
    expect_false(fixture$server$resolve_task_manager$has(document$uri))
    expect_false(fixture$server$member_task_manager$has(document$uri))
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 3L)
}

test_that("Metadata configuration refresh survives a pending newer document version", {
    withr::local_options(languageserver.member_completion = NULL, languageserver.s3_dispatch = NULL)
    testthat::local_mocked_bindings(
        backend_settings_changed = function(...) NULL,
        sync_formatting_capabilities = function(...) NULL,
        .package = "languageserver")
    for (enabled in c(TRUE, FALSE)) package_reuse_pending_configuration(enabled, "pending")
})

test_that("Metadata configuration refresh survives a current parse error and recovery", {
    withr::local_options(languageserver.member_completion = NULL, languageserver.s3_dispatch = NULL)
    testthat::local_mocked_bindings(
        backend_settings_changed = function(...) NULL,
        sync_formatting_capabilities = function(...) NULL,
        .package = "languageserver")
    for (enabled in c(TRUE, FALSE)) package_reuse_pending_configuration(enabled, "error")
})

test_that("Metadata configuration refresh waits for a missing document parse", {
    withr::local_options(languageserver.member_completion = NULL, languageserver.s3_dispatch = NULL)
    testthat::local_mocked_bindings(
        backend_settings_changed = function(...) NULL,
        sync_formatting_capabilities = function(...) NULL,
        .package = "languageserver")
    for (enabled in c(TRUE, FALSE)) {
        package_reuse_pending_configuration(enabled, "missing")
        package_reuse_pending_configuration(enabled, "missing_null_version")
    }
})

test_that("Namespace recovery hints consume deferred refresh with the current preparation modes", {
    withr::local_options(languageserver.member_completion = NULL, languageserver.s3_dispatch = NULL)
    testthat::local_mocked_bindings(
        backend_settings_changed = function(...) NULL,
        sync_formatting_capabilities = function(...) NULL,
        .package = "languageserver")
    for (initial_enabled in c(TRUE, FALSE)) {
        fixture <- package_reuse_fixture(members = initial_enabled, s3 = initial_enabled)
        if (is.null(fixture$server$member_task_manager)) {
            fixture$server$member_task_manager <- SharedTaskManager$new("reuse-hint-members",
                max_running_tasks = 32L, cpu_load = 1)
        }
        document <- package_reuse_document(fixture, "hint")
        package_reuse_start(fixture)
        original_processes <- fixture$state$processes
        document$set_content(2L, c("library(callr)", "processx::value$"))
        enabled <- !initial_enabled
        workspace_did_change_configuration(fixture$server,
            list(settings = list(member_completion = enabled, s3_dispatch = enabled)))
        expect_true(document$member_refresh)
        package_reuse_parse(fixture, document)
        expect_true(document$parse_data$parse_error)
        expect_identical(document$requested_packages$packages, "callr")
        expect_identical(document$requested_packages$namespace_packages, "processx")
        expect_false(document$member_refresh)
        expect_true(fixture$server$resolve_task_manager$has(document$uri))
        expect_identical(fixture$server$member_task_manager$has(document$uri), enabled)
        package_reuse_finish(fixture, original_processes)
        expect_length(fixture$workspace$applied, 0L)
        package_reuse_start(fixture)
        expect_length(fixture$state$processes, 3L)
        replacement <- Filter(function(process) !process$ready, fixture$state$processes)
        expect_identical(vapply(replacement, function(process) process$args$prepare, logical(1L)),
            if (enabled) c(FALSE, TRUE) else FALSE)
        expect_identical(vapply(replacement, function(process) process$args$prepare_s3, logical(1L)),
            if (enabled) c(TRUE, FALSE) else FALSE)
        point <- list(row = 1L, col = nchar("processx::value$"))
        expect_identical(member_metadata_waiting(fixture$server, document$uri, document, point), enabled)
        expect_identical(s3_metadata_waiting(fixture$server, document$uri, document), enabled)

        task <- fixture$server$resolve_task_manager$get_task(document$uri)
        package_reuse_parse(fixture, document)
        expect_identical(fixture$server$resolve_task_manager$get_task(document$uri), task)
        document$set_content(3L, c("library(callr)", "processx::value$field"))
        package_reuse_parse(fixture, document)
        expect_false(document$parse_data$parse_error)
        expect_false(document$member_refresh)
        expect_identical(fixture$server$resolve_task_manager$get_task(document$uri), task)
        package_reuse_start(fixture)
        expect_length(fixture$state$processes, 3L)
        package_reuse_finish(fixture, replacement)
        expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
        expect_identical(is.null(fixture$workspace$member_metadata$catalog("processx")), !enabled)
        expect_identical(is.null(fixture$workspace$s3_metadata$catalog("processx")), !enabled)
        expect_false(member_metadata_waiting(fixture$server, document$uri, document, point))
        expect_false(s3_metadata_waiting(fixture$server, document$uri, document))
        package_reuse_parse(fixture, document)
        expect_false(fixture$server$resolve_task_manager$has(document$uri))
        expect_false(fixture$server$member_task_manager$has(document$uri))
        package_reuse_start(fixture)
        expect_length(fixture$state$processes, 3L)
    }
})

PackageResolutionTransferServer <- R6::R6Class("PackageResolutionTransferServer",
    inherit = LanguageServer,
    private = list(finalize = function() NULL),
    public = list(
        initialize = function(fixture) {
            self$workspaces <- collections::dict()
            self$workspace_cache <- collections::dict()
            self$pending_replies <- fixture$server$pending_replies
            self$request_callbacks <- collections::dict()
            self$resolve_task_manager <- fixture$server$resolve_task_manager
            self$member_task_manager <- fixture$server$member_task_manager
            self$parse_task_manager <- TaskManager$new("reuse-transfer-parse", cpu_load = 1,
                max_running_tasks = 1L)
            self$rootUri <- character()
            self$ClientCapabilities <- list()
            self$add_workspace(character())
        },
        deliver = function(...) invisible(NULL)
    )
)

package_reuse_transfer <- function(move, enabled, parse_state) {
    previous_diagnostics <- lsp_settings$get("diagnostics")
    withr::defer(lsp_settings$set("diagnostics", previous_diagnostics))
    lsp_settings$set("diagnostics", FALSE)
    fixture <- package_reuse_fixture(members = enabled, s3 = enabled)
    temp_root <- fixture$root
    # Keep workspace storage and parser scheduling deterministic while using
    # the server's actual ownership, transfer and metadata-resolution paths.
    testthat::local_mocked_bindings(Workspace = list(new = function(path) {
        root <- if (is.null(path)) file.path(temp_root, "default") else path
        workspace <- package_reuse_workspace(root)
        workspace$root <- path
        workspace$index <- NULL
        workspace$parse_cache <- ByteLruCache$new(16 * 1024^2)
        workspace
    }), .package = "languageserver")
    server <- PackageResolutionTransferServer$new(fixture)
    withr::defer(server$parse_task_manager$stop())
    fixture$server <- server
    parent <- file.path(temp_root, "parent")
    nested <- file.path(parent, "nested")
    dir.create(nested, recursive = TRUE)
    nested_uri <- path_to_uri(nested)
    server$add_workspace(path_to_uri(parent))
    if (move == "remove") server$add_workspace(nested_uri)
    fixture$root <- nested
    uri <- path_to_uri(file.path(nested, ".vdoc.transfer.r"))
    fixture$workspace <- server$get_workspace(uri)
    document <- package_reuse_document(fixture, "transfer")
    source <- fixture$workspace
    original_parsed <- document$parse_data
    original_content <- document$content
    package_reuse_start(fixture)
    original_processes <- fixture$state$processes
    expect_equal(length(original_processes), if (enabled) 2L else 1L)
    if (parse_state %in% c("warm", "force")) {
        package_reuse_finish(fixture, original_processes)
        expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
        if (parse_state == "force") document$member_refresh <- TRUE
    }

    if (parse_state == "pending") {
        document$set_content(2L, c("library(callr)", "value <- 2L"))
    } else if (parse_state == "error") {
        document$set_content(2L, c("library(callr)", "value <- )"))
        package_reuse_parse(fixture, document)
        expect_true(document$parse_data$parse_error)
    } else if (parse_state == "missing") {
        document$parse_data <- NULL
    } else if (parse_state == "namespace_error") {
        document$set_content(2L, c("library(callr)", "processx::value$"))
        package_reuse_parse(fixture, document)
        expect_true(document$parse_data$parse_error)
        expect_identical(document$requested_packages$namespace_packages, "processx")
    }
    source_applied <- source$applied

    if (move == "add") server$add_workspace(nested_uri)
    else server$remove_workspace(nested_uri)
    destination <- server$get_workspace(uri)
    fixture$workspace <- destination
    expect_false(identical(source, destination))
    expect_false(source$documents$has(uri))
    expect_identical(destination$documents$get(uri), document)
    expect_identical(document$requested_packages$packages, "callr")

    deferred <- parse_state %in% c("pending", "error", "missing")
    if (deferred) {
        expect_true(document$member_refresh)
        if (parse_state == "pending") {
            expect_true(server$parse_task_manager$has(uri))
            parse_callback(server, uri, 1L, original_parsed, original_content, cache = FALSE)
        } else if (parse_state == "error") {
            package_reuse_parse(fixture, document)
            expect_true(document$parse_data$parse_error)
        } else {
            expect_true(server$parse_task_manager$has(uri))
            parse_callback(server, uri, document$version, NULL, cache = FALSE)
        }
        expect_true(document$member_refresh)
        package_reuse_finish(fixture, original_processes)
        expect_length(source$applied, 0L)
        expect_length(destination$applied, 0L)
        expect_identical(document$loaded_packages, "callr")
        if (parse_state == "error") {
            document$set_content(3L, c("library(callr)", "value <- 3L"))
        }
        package_reuse_parse(fixture, document)
        expect_false(document$member_refresh)
    } else {
        # Current successful parses and accepted namespace recovery hints
        # resolve in the destination without waiting for another edit.
        expect_false(document$member_refresh)
        if (parse_state == "namespace_error") {
            expect_true(document$parse_data$parse_error)
            expect_false(server$parse_task_manager$has(uri))
            package_reuse_finish(fixture, original_processes)
            expect_length(destination$applied, 0L)
        }
    }
    expect_identical(server$resolve_task_manager$has(uri), parse_state != "warm")
    expect_identical(!is.null(server$member_task_manager) && server$member_task_manager$has(uri),
        enabled && parse_state != "warm")
    package_reuse_start(fixture)
    count <- length(fixture$state$processes)
    if (deferred || parse_state %in% c("namespace_error", "force")) {
        expect_equal(count, if (enabled) 4L else 2L)
    }
    if (parse_state == "warm") expect_equal(count, if (enabled) 2L else 1L)
    task <- server$resolve_task_manager$get_task(uri)
    package_reuse_parse(fixture, document)
    expect_identical(server$resolve_task_manager$get_task(uri), task)
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, count)
    replacement <- Filter(function(process) !process$ready, fixture$state$processes)
    package_reuse_finish(fixture, replacement)
    expect_identical(source$applied, source_applied)
    expect_true(length(destination$applied) > 0L)
    expect_identical(document$loaded_packages, c(startup_packages, "R6", "callr"))
    expect_identical(is.null(destination$member_metadata$catalog("callr")), !enabled)
    expect_identical(is.null(destination$s3_metadata$catalog("callr")), !enabled)
    if (parse_state == "namespace_error") {
        expect_false(is.null(destination$member_metadata$catalog("processx")))
        expect_false(is.null(destination$s3_metadata$catalog("processx")))
        point <- list(row = 1L, col = nchar("processx::value$"))
        expect_false(member_metadata_waiting(server, uri, document, point))
        expect_false(s3_metadata_waiting(server, uri, document))
    }
    package_reuse_parse(fixture, document)
    expect_false(server$resolve_task_manager$has(uri))
    expect_false(!is.null(server$member_task_manager) && server$member_task_manager$has(uri))
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, count)
}

test_that("Workspace transfers retain package refresh for pending document versions", {
    for (move in c("remove", "add")) {
        for (enabled in c(FALSE, TRUE)) package_reuse_transfer(move, enabled, "pending")
    }
})

test_that("Workspace transfers retain package refresh through parse error recovery", {
    for (move in c("remove", "add")) {
        for (enabled in c(FALSE, TRUE)) package_reuse_transfer(move, enabled, "error")
    }
})

test_that("Workspace transfers retain package refresh until a missing parse arrives", {
    for (move in c("remove", "add")) {
        for (enabled in c(FALSE, TRUE)) package_reuse_transfer(move, enabled, "missing")
    }
})

test_that("Workspace transfers resolve successful parses immediately without another refresh", {
    for (move in c("remove", "add")) {
        for (enabled in c(FALSE, TRUE)) package_reuse_transfer(move, enabled, "valid")
    }
})

test_that("Workspace transfers prepare accepted namespace recovery hints without another edit", {
    for (move in c("remove", "add")) package_reuse_transfer(move, TRUE, "namespace_error")
})

test_that("Workspace transfers reuse complete cached results and honor an earlier forced refresh", {
    for (move in c("remove", "add")) {
        for (enabled in c(FALSE, TRUE)) package_reuse_transfer(move, enabled, "warm")
        package_reuse_transfer(move, TRUE, "force")
    }
})

test_that("S3-only saves coalesce a fresh result after running resolution", {
    fixture <- package_reuse_fixture(s3 = TRUE)
    document <- package_reuse_document(fixture, "s3-refresh")
    package_reuse_start(fixture)
    first <- fixture$state$processes[[1L]]
    for (i in 1:3) {
        document$member_refresh <- TRUE
        package_reuse_parse(fixture, document)
    }
    expect_length(fixture$state$processes, 1L)
    expect_identical(first$killed, 0L)
    first$result <- package_reuse_result(first)
    first$result$s3$callr$generation <- "before-save"
    first$ready <- TRUE
    fixture$server$resolve_task_manager$check_tasks()
    expect_null(fixture$workspace$s3_metadata$catalog("callr"))
    expect_true(fixture$server$resolve_task_manager$has(document$uri))
    package_reuse_start(fixture)
    expect_length(fixture$state$processes, 2L)
    fresh <- fixture$state$processes[[2L]]
    expect_true(fresh$args$prepare_s3)
    expect_false(fresh$args$prepare)
    fresh$result <- package_reuse_result(fresh)
    fresh$result$s3$callr$generation <- "after-save"
    fresh$ready <- TRUE
    fixture$server$resolve_task_manager$check_tasks()
    expect_identical(fixture$workspace$s3_metadata$catalog("callr")$generation, "after-save")
    expect_false(fixture$server$resolve_task_manager$has(document$uri))
    later <- package_reuse_document(fixture, "s3-cached")
    expect_false(fixture$server$resolve_task_manager$has(later$uri))
    expect_length(fixture$state$processes, 2L)
})

Try the languageserver package in your browser

Any scripts or data that you put into this service are public.

languageserver documentation built on Nov. 16, 2026, 9:07 a.m.