R/member-analysis.R

Defines functions member_receiver_cache_value member_receiver_cacheable member_completion_value member_local_value member_local_binding member_binding_cacheable member_document_cache_revision member_source_prefix member_history_position member_package_scope_required member_ordinary_request member_symbol_required member_syntax_names

# Syntax summaries include defaults, which all.names() omits on pairlists.
# The native walk deduplicates symbols without allocating per-node R lists.
member_syntax_names <- function(expr) {
    .Call("member_syntax_names_c", expr, PACKAGE = "languageserver")
}

member_symbol_required <- function(workspace, document) {
    data <- document$parse_data
    if (!identical(document$version, data$version) || isTRUE(data$parse_error)) return(TRUE)
    if (!isFALSE(data$member_data$symbol_scope)) return(TRUE)
    member_package_scope_required(workspace, data$member_data, "symbol_scope")
}

member_ordinary_request <- function(workspace, document) {
    isTRUE(document$member_ordinary_edit) && !isTRUE(document$parse_data$parse_error) &&
        isFALSE(document$parse_data$member_data$class_scope) &&
        isFALSE(document$parse_data$member_data$symbol_scope) &&
        !member_package_scope_required(workspace, document$parse_data$member_data, "symbol_scope")
}

member_package_scope_required <- function(workspace, data, capability) {
    metadata <- workspace$member_metadata
    if (is.null(metadata)) return(FALSE)
    packages <- unique(c(data$packages, vapply(data$imports, function(item) {
        if (length(item$expr) < 2L) return("")
        name <- member_name(item$expr[[2L]])
        if (is.null(name)) "" else name
    }, character(1L))))
    for (package in intersect(packages, metadata$keys())) {
        candidate <- if (is.function(metadata$catalog)) metadata$catalog(package) else metadata$get(package)
        if (!isFALSE(candidate[[capability]])) return(TRUE)
    }
    FALSE
}

# Histories are ordered by their end position. Earlier assignments are looked
# up repeatedly while following aliases and resolving shadowed intrinsics.
member_history_position <- function(history, at) {
    lo <- 1L
    hi <- length(history)
    while (lo <= hi) {
        middle <- as.integer(floor((lo + hi) / 2L))
        if (member_before(history[[middle]]$end, at)) lo <- middle + 1L else hi <- middle - 1L
    }
    hi
}

# Incremental source fingerprints are prepared with the parse, not rebuilt by
# providers. Each source segment is hashed once. Invalid virtual source ranges
# disable reuse rather than making recovery fail.
member_source_prefix <- function(content, start, end, prefix) {
    if (is.null(prefix) || length(end) != 2L || anyNA(end) || !member_before(start, end) ||
            end[[1L]] < 0L || end[[1L]] >= length(content) || end[[2L]] < 0L ||
            is.na(content[[end[[1L]] + 1L]]) ||
            end[[2L]] > nchar(content[[end[[1L]] + 1L]])) return(NULL)
    lines <- content[seq.int(start[[1L]] + 1L, end[[1L]] + 1L)]
    if (anyNA(lines)) return(NULL)
    lines[[length(lines)]] <- substr(lines[[length(lines)]], 1L, end[[2L]])
    lines[[1L]] <- substring(lines[[1L]], start[[2L]] + 1L)
    digest::digest(list(prefix, start, end, lines), algo = "xxhash64")
}

member_document_cache_revision <- function(document, metadata) {
    revision <- if (is.null(metadata)) 0L else if (is.function(metadata$revision)) metadata$revision() else NULL
    identity <- list(metadata = if (is.function(metadata$identity)) metadata$identity() else metadata,
        revision = revision)
    document$member_binding_cache <- analysis_cache(document, "member-bindings", identity, max_bytes = 4 * 1024^2)
    if (!identical(document$member_revision, identity)) {
        document$member_receivers$clear()
        document$member_revision <- identity
    }
    revision
}

# Cross-edit summaries must not capture lexical positions, source closures or
# mutable object identities. Package function keys are tied to the metadata
# revision; uncertain candidates have the exact same source/context key.
member_binding_cacheable <- function(value, depth = 0L) {
    if (is.null(value)) return(TRUE)
    if (depth > 8L || !is.null(value$function_expr) || !is.null(value$closure) ||
            !is.null(value$binding_expr) || !is.null(value$binding_env) ||
            !is.null(value$r6_class) || !is.null(value$r6_identity) || !is.null(value$r6_role) ||
            !is.null(value$s7_descriptor) || !is.null(value$s7_generator) || !is.null(value$s4_generator) ||
            (!is.null(value$function_key) && is.null(value$metadata)) ||
            (isTRUE(value$known_literal) && (!is.atomic(value$literal) || is.object(value$literal)))) return(FALSE)
    children <- c(value$fields, value$slots, value$elements, value$possible_returns,
        value[c("receiver_value", "element_shape", "result_shape", "r6_private", "r6_super", "r6_self")])
    all(vapply(children, member_binding_cacheable, logical(1L), depth + 1L))
}

# Lazy local values keep the lexical state from before the assignment. The
# memo belongs to this recovered scope, never to a package-wide summary.
member_local_binding <- function(expr, bindings, referenced = member_syntax_names(expr), lookup = NULL) {
    # Keep only lexical dependencies. Copying every earlier local into every
    # deferred binding makes a flat method quadratic in retained state.
    internal <- c(".__member_position__", ".__member_properties__", ".__s4_classes__",
        ".__s7_package__", ".__s7_constructing__")
    captured <- if (is.null(lookup)) {
        bindings[intersect(names(bindings), c(referenced, internal))]
    } else {
        # The mutable lookup stays in the scope walker. Copy its current
        # values so later assignments cannot change this lexical snapshot.
        keys <- unique(c(referenced, internal))
        values <- mget(keys, lookup, inherits = FALSE, ifnotfound = list(NULL))
        values[!vapply(values, is.null, logical(1L))]
    }
    list(binding_expr = expr, binding_env = captured,
        binding_cache = new.env(hash = FALSE, parent = emptyenv()))
}

member_local_value <- function(value, index, budget, depth = 0L, trail = character(),
    receiver = NULL, context = NULL) {
    if (is.null(value$binding_expr)) return(value)
    cache <- value$binding_cache
    if (!is.null(cache) && exists("value", cache, inherits = FALSE)) return(cache$value)
    result <- member_infer(value$binding_expr, index, value$binding_env, receiver,
        depth = depth + 1L, trail = trail, budget = budget, context = context)
    if (!is.null(cache) && !isTRUE(budget$exhausted) && !isTRUE(budget$transient)) cache$value <- result
    result
}

# Ordinary completion needs the binding kind and R6 identity, not every list
# element. A proven base list cannot be a function or R6 instance, even when
# its arguments contain constructors. Keep the full deferred value for member
# access and never store this outline in its inference memo.
member_completion_value <- function(value, index, budget) {
    if (!is.null(value$binding_expr) && !is.null(value$binding_cache) && !isTRUE(budget$exhausted)) {
        expr <- value$binding_expr
        if (!is.call(expr) && !is.symbol(expr) && !is.object(expr)) return(member_literal(expr))
        if (member_head(expr, "list") && !"list" %in% names(value$binding_env) &&
                is.null(member_lookup(index$definitions, "list")) &&
                !length(member_lookup(index$document_bindings, "list"))) {
            return(member_value(type = "list"))
        }
    }
    member_local_value(value, index, budget)
}

member_receiver_cacheable <- function(value, index, budget) {
    if (isTRUE(budget$exhausted) || (!length(value$type) && !length(value$possible_returns))) return(FALSE)
    if (!isTRUE(budget$transient)) return(TRUE)
    if (!length(value$type)) {
        return(all(vapply(value$possible_returns, member_receiver_cacheable, logical(1L), index, budget)))
    }
    # Alias histories can start in a generic document context. The declared
    # native surface belongs to the receiver's namespace, regardless of which
    # package was selected while recovering the cursor.
    owner <- member_package_context(index, value$member_package)
    if (is.null(owner)) return(FALSE)
    # Recursive argument analysis must not preserve partial instance fields.
    # A native-backed class-only result has a complete declared member surface
    # independent of argument values; retain just that proven surface.
    length(value$type) == 1L && is.null(value$reason) && is.null(value$fields) &&
        is.null(value$slots) && is.null(value$function_expr) && is.null(value$closure) &&
        is.null(value$binding_expr) && is.null(value$elements) && is.null(value$element_shape) &&
        is.null(value$result_shape) && is.null(value$r6_class) && !isTRUE(value$open) &&
        (any(owner$members[[value$type]] %in% owner$native_factories, na.rm = TRUE) ||
            any(vapply(owner$properties[[value$type]], function(property) {
                length(property$type) == 1L &&
                    any(owner$members[[property$type]] %in% owner$native_factories, na.rm = TRUE)
            }, logical(1L))))
}

member_receiver_cache_value <- function(value, index, budget) {
    if (member_receiver_cacheable(value, index, budget)) return(value)
    if (isTRUE(budget$exhausted) || !isTRUE(budget$transient) ||
            length(value$type) || !length(value$possible_returns)) return(NULL)
    # A possible native result may carry argument-dependent instance fields.
    # Its declared surface is still useful, but those partial fields cannot be
    # retained. The existing native-surface check verifies every projection.
    candidates <- lapply(value$possible_returns, function(candidate) {
        candidate$fields <- NULL
        if (member_receiver_cacheable(candidate, index, budget)) candidate else NULL
    })
    if (any(vapply(candidates, is.null, logical(1L)))) return(NULL)
    value$possible_returns <- candidates
    value
}

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.