Nothing
# Package-independent extraction of declarative constructors and registry dispatch.
# Every name and relation below comes from syntax or inert namespace bindings.
member_data <- function(node, constants = list(), depth = 0L) {
if (depth > 12L || missing(node)) {
return(NULL)
}
if (is.atomic(node)) {
return(node)
}
if (is.symbol(node)) {
return(constants[[as.character(node)]])
}
if (!is.call(node)) {
return(NULL)
}
head <- member_name(node[[1L]])
if (is.null(head)) {
return(NULL)
}
if (!head %in% c("c", "setdiff", "names")) {
return(NULL)
}
args <- as.list(node)[-1L]
values <- lapply(args, member_data, constants, depth + 1L)
if (head == "c" && all(vapply(values, function(x) !is.null(x), logical(1L)))) {
return(unlist(values))
}
if (head == "setdiff" && length(values) == 2L && all(vapply(values, function(x) !is.null(x), logical(1L)))) {
return(setdiff(values[[1L]], values[[2L]]))
}
if (head == "names" && length(args) == 1L && is.symbol(args[[1L]])) {
return(names(constants[[as.character(args[[1L]])]]))
}
NULL
}
member_constructor <- function(fn) {
if (!member_head(fn, "function")) {
return(NULL)
}
body <- fn[[3L]]
if (!member_head(body, "{")) {
return(NULL)
}
statements <- as.list(body)[-1L]
if (!length(statements)) return(NULL)
last <- statements[[length(statements)]]
if (member_head(last, "return") && length(last) == 2L) last <- last[[2L]]
target <- member_name(last)
if (is.null(target)) {
return(NULL)
}
classes <- NULL
fields <- list()
aliases <- list()
created <- FALSE
for (node in statements) {
if (member_head(node, "<-") && is.symbol(node[[2L]])) {
aliases[as.character(node[[2L]])] <- list(node[[3L]])
if (identical(member_name(node[[2L]]), target) && member_head(node[[3L]], "new.env")) created <- TRUE
}
if (member_head(node, "<-") && member_head(node[[2L]], "class") &&
identical(member_name(node[[2L]][[2L]]), target)) {
classes <- member_strings(node[[3L]])
# Native-dependent subclasses precede a literal base-class suffix.
# Retain that guaranteed suffix without inventing a subtype.
if (!length(classes) && member_head(node[[3L]], "c")) {
parts <- as.list(node[[3L]])[-1L]
literal <- vapply(parts, is.character, logical(1L))
last_dynamic <- max(c(0L, which(!literal)))
if (last_dynamic < length(parts)) classes <- unlist(parts[seq.int(last_dynamic + 1L, length(parts))])
}
}
if (member_head(node, "<-") && member_head(node[[2L]], "$") &&
identical(member_name(node[[2L]][[2L]]), target)) {
name <- member_name(node[[2L]][[3L]])
rhs <- node[[3L]]
if (is.symbol(rhs) && !is.null(aliases[[as.character(rhs)]])) rhs <- aliases[[as.character(rhs)]]
fields[name] <- list(list(expr = rhs, active = FALSE))
}
if (member_head(node, "makeActiveBinding") && length(node) >= 4L &&
identical(member_name(node[[4L]]), target)) {
name <- member_strings(node[[2L]])
if (length(name) == 1L) fields[name] <- list(list(expr = node[[3L]], active = TRUE))
}
}
# Conditional fields and computed class vectors are not unconditional
# constructor guarantees. Only literal top-level declarations qualify.
if (!created || !length(classes)) {
return(NULL)
}
list(type = classes[[1L]], classes = classes, fields = fields, body = body, target = target)
}
member_definition <- function(definitions, key) {
seen <- character()
while (is.symbol(member_lookup(definitions, key))) {
if (key %in% seen) {
return(NULL)
}
seen <- c(seen, key)
key <- as.character(definitions[[key]])
}
member_lookup(definitions, key)
}
member_returned_function <- function(fn) {
if (!member_head(fn, "function")) {
return(NULL)
}
body <- fn[[3L]]
statements <- if (member_head(body, "{")) as.list(body)[-1L] else list(body)
if (!length(statements)) {
return(NULL)
}
last <- utils::tail(statements, 1L)[[1L]]
if (member_head(last, "return") && length(last) == 2L) last <- last[[2L]]
if (member_head(last, "function")) {
return(list(fn = last, prelude = statements[-length(statements)]))
}
if (!is.symbol(last)) {
return(NULL)
}
target <- as.character(last)
returned <- NULL
copied <- NULL
prelude <- list()
for (node in statements[-length(statements)]) {
if (member_head(node, "<-") && identical(member_name(node[[2L]]), target) &&
member_head(node[[3L]], "function")) {
returned <- node[[3L]]
} else if (member_head(node, "<-") && member_head(node[[2L]], "formals") &&
identical(member_name(node[[2L]][[2L]]), target) && member_head(node[[3L]], "formals")) {
copied <- member_name(node[[3L]][[2L]])
} else if (is.null(returned)) prelude[[length(prelude) + 1L]] <- node
}
if (is.null(returned)) {
return(NULL)
}
list(fn = returned, prelude = prelude, copied = copied)
}
member_source_registries <- function(input) {
definitions <- input$definitions
registries <- list()
for (key in names(definitions)) {
if (member_head(definitions[[key]], "new.env")) registries[key] <- list(character())
}
for (key in names(definitions)) {
parts <- strsplit(key, "$", fixed = TRUE)[[1L]]
if (length(parts) == 2L && parts[[1L]] %in% names(registries)) {
registries[[parts[[1L]]]][parts[[2L]]] <- key
}
}
# Validate the source population recipe before interpreting a literal
# prefix-to-environment map. An unrelated named list is not a registry.
collectors <- character()
for (key in names(definitions)) {
fn <- definitions[[key]]
if (!member_head(fn, "function") || length(fn[[2L]]) < 2L) next
args <- names(fn[[2L]])
enumerates <- strips <- assigns <- FALSE
member_walk(fn[[3L]], function(node) {
if (member_head(node, "ls") && identical(member_name(as.list(node)$pattern), args[[2L]])) enumerates <<- TRUE
if (member_head(node, "sub") && length(node) >= 4L &&
identical(member_name(node[[2L]]), args[[2L]]) && identical(node[[3L]], "")) {
strips <<- TRUE
}
if (member_head(node, "assign") && identical(member_name(as.list(node)$envir), args[[1L]])) assigns <<- TRUE
})
if (enumerates && strips && assigns) collectors <- c(collectors, key)
}
maps <- character()
for (code in input$expressions) {
member_walk(code, function(node) {
if (!is.call(node) || length(node) < 3L) {
return()
}
key <- member_name(node[[1L]])
if (is.null(key) || !key %in% collectors) {
return()
}
destination <- node[[2L]]
pattern <- node[[3L]]
if (!member_head(destination, "[[") || !member_head(pattern, "sprintf") ||
length(pattern) != 3L || !identical(pattern[[2L]], "^%s") ||
!identical(destination[[3L]], pattern[[3L]])) {
return()
}
map <- member_name(destination[[2L]])
if (!is.null(map)) maps <<- union(maps, map)
})
}
for (map in maps) {
node <- definitions[[map]]
if (!member_head(node, "list")) next
entries <- as.list(node)[-1L]
for (prefix in names(entries)) {
registry <- member_name(entries[[prefix]])
if (is.null(registry) || !registry %in% names(registries) || !nzchar(prefix)) next
keys <- names(definitions)[startsWith(names(definitions), prefix)]
registries[[registry]] <- c(
registries[[registry]],
stats::setNames(keys, substring(keys, nchar(prefix) + 1L))
)
}
}
registries
}
member_package_index <- function(input) {
index <- member_generic_index("")
index$package <- input$package
index$definitions <- input$definitions
index$locations <- input$locations
index$exports <- input$exports
index$generic_external <- input$generic_external
index$subset_registry <- input$subset_registry
index$subset_registry_complete <- isTRUE(input$subset_registry_complete)
index$registries <- if (!is.null(input$registries)) input$registries else member_source_registries(input)
index$intrinsics <- if (!is.null(input$intrinsics)) input$intrinsics else character()
index$nonreturning_functions <- intersect(c("stop", "abort"), c(member_base_intrinsics, index$intrinsics))
index$package_roots <- list()
index$constructor_inputs <- list()
index$namespace_owners <- list()
index$delegation <- list()
index$method_receivers <- list()
index$methods_attached <- FALSE
index$s4_classes <- if (is.null(input$s4_classes)) list() else input$s4_classes
index$s4_dependencies <- input$s4_dependencies
index$s7_capabilities <- input$s7_capabilities
index$s7_dependencies <- input$s7_dependencies
index$s7_attached <- identical(input$package, "S7")
for (name in names(input$s7_roots)) index$package_roots[name] <- input$s7_roots[name]
declarations <- list()
for (code in input$expressions) {
for (node in code) declarations <- member_s4_effect(node, index, declarations)
}
if (!is.null(declarations$.__s4_classes__)) {
index$s4_classes <- utils::modifyList(index$s4_classes, declarations$.__s4_classes__)
}
constants <- index$registries
for (key in names(index$definitions)) {
node <- index$definitions[[key]]
literal <- member_data(node, constants)
if (!is.null(literal)) constants[key] <- list(literal)
# S7 class declarations expose literal properties without constructing
# an instance. Accept only a verified imported descriptor constructor.
if (member_head(node, "new_class") && "new_class" %in% index$intrinsics) {
type <- member_strings(node[[2L]])
properties <- as.list(node)$properties
if (length(type) == 1L && member_head(properties, "list")) {
fields <- names(as.list(properties)[-1L])
index$constructor_types[key] <- list(type)
index$classes[type] <- list(type)
index$members[type] <- list(stats::setNames(rep(NA_character_, length(fields)), fields))
}
}
ctor <- member_constructor(node)
if (is.null(ctor)) next
index$constructors[key] <- list(ctor)
index$classes[ctor$type] <- list(ctor$classes)
fields <- names(ctor$fields)
index$members[ctor$type] <- list(stats::setNames(rep(NA_character_, length(fields)), fields))
# Constructor-installed bound closures are inferred from the assignment
# RHS, regardless of native generator, class or factory naming scheme.
for (field in fields) {
recipe <- ctor$fields[[field]]
factory <- if (is.call(recipe$expr)) member_key(recipe$expr[[1L]]) else NULL
returned <- member_returned_function(member_definition(index$definitions, factory))
if (!is.null(returned) && is.null(returned$copied)) {
index$native_factories <- unique(c(index$native_factories, factory))
index$members[[ctor$type]][field] <- factory
}
}
}
for (key in names(input$descriptors)) {
descriptor <- input$descriptors[[key]]
index$constructor_types[key] <- list(descriptor$type)
index$classes[descriptor$type] <- list(descriptor$type)
old <- index$members[[descriptor$type]]
fields <- setdiff(descriptor$fields, names(old))
index$members[descriptor$type] <- list(c(old, stats::setNames(rep(NA_character_, length(fields)), fields)))
}
# UseMethod and standard S3 method IDs supply input-class constraints for
# constructors. Multiple generics can share a class without a global wrap map.
for (key in names(index$definitions)) {
node <- index$definitions[[key]]
if (!member_head(node, "function")) next
generic <- NULL
member_walk(node[[3L]], function(child) {
if (member_head(child, "UseMethod")) generic <<- member_strings(child[[2L]])
}, descend_functions = FALSE)
if (length(generic) != 1L) next
constructor_names <- as.character(names(index$constructors))
for (method in constructor_names[startsWith(constructor_names, paste0(generic, "."))]) {
formal <- names(index$definitions[[method]][[2L]])[[1L]]
index$constructor_inputs[[method]][formal] <- list(member_value(type = substring(method, nchar(generic) + 2L)))
}
}
for (registry in names(index$registries)) {
index$members[registry] <- list(index$registries[[registry]])
index$package_roots[registry] <- list(member_value(type = registry))
}
for (registry in names(index$registries)) {
for (field in names(index$registries[[registry]])) {
key <- index$registries[[registry]][[field]]
if (key %in% names(index$package_roots)) {
index$members[[registry]][field] <- NA_character_
index$properties[[registry]][field] <- list(index$package_roots[[key]])
}
}
}
# Every static object surface is discovered, including named lists, bundles
# and exported roots. Active names are retained but getters are only analyzed.
for (name in names(input$snapshots)) {
snapshot <- input$snapshots[[name]]
shape <- member_snapshot_shape(snapshot, input$package)
if (identical(snapshot$kind, "environment")) shape$type <- name
for (field in names(index$registries[[name]])) {
if (is.null(shape$fields[[field]]$s7_generator)) {
stored <- shape$fields[[field]]
method <- if (identical(snapshot$kind, "r6_instance") || !is.null(stored$s4_class) ||
length(stored$closure)) stored else member_value()
method$function_key <- index$registries[[name]][[field]]
method$metadata <- input$package
shape$fields[field] <- list(method)
}
}
for (field in names(input$links[[name]])) {
linked <- shape$fields[[field]]
if (identical(linked$type, "environment") && is.null(linked$r6_role)) {
shape$fields[field] <- list(member_value(type = input$links[[name]][[field]],
classes = linked$classes, default_dollar = linked$default_dollar,
member_package = input$package))
}
}
index$package_roots[name] <- list(shape)
for (field in names(shape$fields)) {
if (!field %in% names(index$members[[name]])) index$members[[name]][field] <- NA_character_
if (identical(snapshot$kind, "environment") && is.null(shape$fields[[field]]$function_key)) {
index$properties[[name]][field] <- list(shape$fields[[field]])
}
}
}
# Registry lookup branches describe membership, precedence, lexical receiver
# rebinding, returned method factories and delegation through closure factories.
definition_names <- as.character(names(index$definitions))
for (key in definition_names[startsWith(definition_names, "$.")]) {
fn <- index$definitions[[key]]
if (!member_head(fn, "function")) next
type <- substring(key, 3L)
formals <- names(fn[[2L]])
if (length(formals) < 2L) next
locals <- constants
member_walk(fn[[3L]], function(node) {
if (member_head(node, "<-") && is.symbol(node[[2L]])) {
value <- member_data(node[[3L]], locals)
if (!is.null(value)) locals[as.character(node[[2L]])] <<- list(value)
}
}, descend_functions = FALSE)
members <- character()
inspect <- function(node) {
if (!is.call(node)) {
return(invisible(NULL))
}
if (member_head(node, "if")) {
condition <- node[[2L]]
allowed <- if (member_head(condition, "%in%") &&
identical(member_name(condition[[2L]]), formals[[2L]])) {
member_data(condition[[3L]], locals)
} else {
NULL
}
branch <- node[[3L]]
registry <- variable <- receiver_name <- NULL
factory_call <- NULL
bound_factory <- FALSE
member_walk(branch, function(child) {
if (!is.call(child)) {
return()
}
if (member_head(child, "[[") && member_name(child[[2L]]) %in% names(index$registries) &&
identical(member_name(child[[3L]]), formals[[2L]])) {
registry <<- member_name(child[[2L]])
}
if (member_head(child, "<-") && member_head(child[[3L]], "[[")) variable <<- member_name(child[[2L]])
if (member_head(child, "<-") && identical(member_name(child[[3L]]), formals[[1L]])) receiver_name <<- member_name(child[[2L]])
if (is.call(child[[1L]]) && member_head(child[[1L]], "[[")) bound_factory <<- TRUE
returned <- member_returned_function(member_definition(index$definitions, member_key(child[[1L]])))
if (!is.null(returned) && !is.null(returned$copied)) factory_call <<- child
}, descend_functions = FALSE)
if (!is.null(registry) && !is.null(allowed)) {
values <- index$registries[[registry]][intersect(allowed, names(index$registries[[registry]]))]
for (name in names(values)) {
original_key <- values[[name]]
if (bound_factory) index$native_factories <- unique(c(index$native_factories, original_key))
if (!is.null(receiver_name)) index$method_receivers[[paste(type, original_key, sep = "|")]] <- receiver_name
if (!is.null(factory_call)) {
factory_key <- member_key(factory_call[[1L]])
wrapper <- member_definition(index$definitions, factory_key)
returned <- member_returned_function(wrapper)
original <- member_definition(index$definitions, original_key)
if (!member_head(original, "function")) next
derived <- paste0(".delegated:", type, ":", name)
index$definitions[derived] <- list(as.call(list(as.name("function"), original[[2L]], returned$fn[[3L]])))
args <- as.list(factory_call)[-1L]
# Bind syntax arguments to factory formals, substituting
# the dispatch receiver and the selected original method.
captures <- list()
for (i in seq_along(args)) {
formal <- if (!is.null(names(args)) && nzchar(names(args)[[i]])) names(args)[[i]] else names(wrapper[[2L]])[[i]]
captures[formal] <- list(args[[i]])
}
index$delegation[derived] <- list(list(
original = original_key,
captures = captures, prelude = returned$prelude,
receiver = formals[[1L]], variable = variable
))
values[[name]] <- derived
}
}
members <<- c(members, values[!names(values) %in% names(members)])
}
if (length(node) == 4L) inspect(node[[4L]])
} else if (member_head(node, "{")) for (child in as.list(node)[-1L]) inspect(child)
invisible(NULL)
}
inspect(fn[[3L]])
old <- index$members[[type]]
index$members[type] <- list(c(members, old[!names(old) %in% names(members)]))
}
# Constructor constraints and registry-derived namespaces propagate through
# a bounded fixed point; no constructor or active property is called.
for (pass in seq_len(4L)) {
for (key in names(index$constructors)) {
ctor <- index$constructors[[key]]
env <- index$package_roots
for (name in names(index$constructor_inputs[[key]])) env[name] <- list(index$constructor_inputs[[key]][[name]])
env[ctor$target] <- list(member_value(type = ctor$type))
for (field in names(ctor$fields)) {
if (!is.na(index$members[[ctor$type]][[field]])) next
recipe <- ctor$fields[[field]]
expr <- recipe$expr
if (isTRUE(recipe$active) && member_head(expr, "function")) expr <- expr[[3L]]
value <- member_infer(expr, index, env)
if (length(value$type) == 1L && value$type != ".never") index$properties[[ctor$type]][field] <- list(value)
}
member_walk(ctor$body, function(node) {
if (!member_head(node, "makeActiveBinding") || length(node) < 4L ||
!identical(member_name(node[[4L]]), ctor$target)) {
return()
}
member_walk(node[[3L]], function(child) {
if (!is.call(child) || !member_head(child[[1L]], "[[")) {
return()
}
registry <- member_name(child[[1L]][[2L]])
methods <- member_lookup(index$registries, registry)
if (is.null(methods) || length(child) != 2L ||
!identical(member_name(child[[2L]]), ctor$target)) {
return()
}
index$namespace_owners[[registry]] <- unique(c(index$namespace_owners[[registry]], ctor$type))
for (name in names(methods)) {
target <- member_lookup(index$constructors, methods[[name]])
if (is.null(target)) next
formal <- names(index$definitions[[methods[[name]]]][[2L]])[[1L]]
index$constructor_inputs[[methods[[name]]]][formal] <- list(member_value(type = ctor$type))
index$properties[[ctor$type]][name] <- list(member_value(type = target$type))
index$members[[ctor$type]][name] <- NA_character_
}
})
})
}
index$cache <- new.env(parent = emptyenv())
}
for (name in names(input$snapshots)) {
for (field in names(input$snapshots[[name]]$fields)) {
record <- input$snapshots[[name]]$fields[[field]]
if (identical(record$kind, "active") && member_head(record$syntax, "function")) {
env <- c(lapply(record$captures, member_literal), index$package_roots)
index$properties[[name]][field] <- list(member_infer(record$syntax[[3L]], index, env))
}
}
}
for (key in names(index$definitions)) {
fn <- index$definitions[[key]]
if (!member_head(fn, "function")) next
member_walk(fn[[3L]], function(node) {
if (!member_head(node, "assign") || length(node) < 4L) {
return()
}
args <- as.list(node)[-1L]
registry <- member_name(if (!is.null(args$envir)) args$envir else args[[3L]])
name_arg <- member_name(args[[1L]])
value_arg <- member_name(args[[2L]])
if (is.null(registry) || !registry %in% names(index$namespace_owners) ||
!all(c(name_arg, value_arg) %in% names(fn[[2L]]))) {
return()
}
index$registration_rules[key] <- list(list(
formals = names(fn[[2L]]),
name_arg = name_arg, value_arg = value_arg, owners = index$namespace_owners[[registry]]
))
}, descend_functions = FALSE)
}
# Source-only active property declarations and literal registration loops.
# These recipes are analyzed against lexical metadata, never executed.
for (code in input$expressions) {
member_walk(code, function(node) {
if (!member_head(node, "lapply") || length(node) < 3L ||
!member_head(node[[3L]], "function")) {
return()
}
values <- member_data(node[[2L]], constants)
if (!is.character(values) || length(values) > 256L) {
return()
}
variable <- names(node[[3L]][[2L]])[[1L]]
member_walk(node[[3L]][[3L]], function(child) {
if (!member_head(child, "makeActiveBinding") || length(child) < 4L ||
!identical(member_name(child[[2L]]), variable)) {
return()
}
target <- member_name(child[[4L]])
if (is.null(target) || !target %in% names(index$package_roots)) {
return()
}
getter <- child[[3L]]
if (!member_head(getter, "function")) {
return()
}
for (name in values) {
env <- index$package_roots
env[variable] <- list(member_literal(name))
index$members[[target]][name] <- NA_character_
index$properties[[target]][name] <- list(member_infer(getter[[3L]], index, env))
}
})
})
for (node in code) {
if (!member_head(node, "makeActiveBinding") || length(node) < 4L ||
!member_head(node[[3L]], "function")) {
next
}
name <- member_strings(node[[2L]])
target <- member_name(node[[4L]])
if (length(name) != 1L || is.null(target) || !target %in% names(index$package_roots)) next
index$members[[target]][name] <- NA_character_
index$properties[[target]][name] <- list(member_infer(node[[3L]][[3L]], index, index$package_roots))
}
}
index$record_dispatch_classes <- unique(unlist(lapply(index$classes, function(x) utils::tail(x, 1L))))
for (name in names(index$definitions)) {
recipe <- member_s4_recipe(index$definitions[[name]], index, list())
if (!is.null(recipe) && is.null(recipe$union)) {
index$package_roots[name] <- list(member_value(type = "function",
s4_generator = list(name = recipe$name, package = index$package)))
}
}
for (name in names(input$s4_roots)) index$package_roots[name] <- input$s4_roots[name]
for (name in names(index$definitions)) {
node <- index$definitions[[name]]
if (identical(member_s7_method(node, index, index$package_roots), "new_class")) {
value <- member_infer(node, index, index$package_roots)
if (!is.null(value$s7_generator)) index$package_roots[name] <- list(value)
}
}
for (name in names(input$s7_roots)) index$package_roots[name] <- input$s7_roots[name]
for (name in names(input$s4_objects)) {
class <- input$s4_objects[[name]]
if (is.null(index$package_roots[[name]]$s4_class)) {
index$package_roots[name] <- list(member_s4_shape(class$name, index, list(), class$package))
}
}
index$roots <- member_public_roots(index, input)
for (name in names(index$roots)) index$namespace_roots[paste(input$package, name, sep = "::")] <- list(index$roots[[name]])
member_prepare_returns(index)
index$cache <- new.env(parent = emptyenv())
index
}
# Probe callable package surfaces in the worker, then spend the remaining
# budget on expensive bodies. Parameter count alone misses short wrappers
# which repeatedly infer argument conversion, dispatch and delegated methods.
member_prepare_returns <- function(index, max_nodes = 40000L, max_bytes = 1024^2) {
index$method_results <- list()
index$generic_returns <- list()
backed <- names(index$properties)[vapply(index$properties, function(fields) {
any(vapply(fields, function(value) {
length(value$type) == 1L &&
any(index$members[[value$type]] %in% index$native_factories, na.rm = TRUE)
}, logical(1L)))
}, logical(1L))]
backed <- intersect(backed, names(index$classes))
if (!length(backed)) return(invisible(NULL))
candidates <- new.env(hash = TRUE, parent = emptyenv())
add <- function(keys, type = NULL, generic = NULL) {
for (key in unique(keys[!is.na(keys)])) {
fn <- member_definition(index$definitions, key)
if (!member_head(fn, "function")) next
cost <- length(member_syntax_names(fn)) + length(fn[[2L]])
if (cost < 6L && is.null(generic)) next
id <- if (is.null(type)) key else paste(type, key, sep = "|")
item_generic <- if (is.null(generic)) candidates[[id]]$generic else generic
candidates[[id]] <- list(key = key, type = type, fn = fn, generic = item_generic)
}
}
add(names(index$definitions)[vapply(index$definitions, function(fn) {
member_head(fn, "function") && length(fn[[2L]]) >= 10L
}, logical(1L))])
for (key in index$exports) {
add(key)
add(unname(index$members[[key]]))
fn <- member_definition(index$definitions, key)
if (!member_head(fn, "function")) next
generic <- s3_generic_descriptor(fn)
if (!is.null(generic)) {
methods <- names(index$definitions)[startsWith(names(index$definitions), paste0(generic$name, "."))]
add(methods, generic = generic$name)
}
}
types <- intersect(names(index$members), names(index$classes))
types <- types[order(vapply(index$members[types], length, integer(1L)), types)]
for (type in types) {
if (any(index$members[[type]] %in% index$native_factories, na.rm = TRUE)) next
fields <- names(index$properties[[type]])[vapply(index$properties[[type]], function(value) {
length(value$type) == 1L &&
any(index$members[[value$type]] %in% index$native_factories, na.rm = TRUE)
}, logical(1L))]
keys <- unique(unname(index$members[[type]]))
keys <- keys[!is.na(keys)]
add(keys[vapply(keys, function(key) {
fn <- member_definition(index$definitions, key)
member_head(fn, "function") && (length(fn[[2L]]) >= 10L ||
any(fields %in% member_syntax_names(fn)))
}, logical(1L))], type)
}
candidates <- as.list(candidates, all.names = TRUE)
if (!length(candidates)) return(invisible(NULL))
# Cover exported surfaces and small receiver interfaces before large
# method registries can spend the whole package's preparation budget.
candidates <- candidates[order(vapply(candidates, function(item) {
if (length(item$fn[[2L]]) >= 10L) -1L else if (is.null(item$type)) 0L else match(item$type, types)
}, integer(1L)), names(candidates))]
# Probe new wrappers independently. Feeding their class-only results back
# into preparation can hide fields needed by subsequent dispatch.
preparation_index <- list2env(as.list(index), parent = emptyenv())
preparation_index$method_results <- list()
state <- new.env(hash = FALSE, parent = emptyenv())
state$remaining <- max_nodes
state$bytes <- 0
recoverable <- function(value, declared, depth = 0L, element = FALSE) {
if (depth > 16L || isTRUE(value$open) ||
((!element || length(value$type)) && !identical(value$type, declared$type)) ||
!identical(value$function_key, declared$function_key) ||
!is.null(value$function_expr) || !is.null(value$closure) ||
!is.null(value$elements) ||
(!is.null(value$element_shape) && (is.null(declared$element_shape) ||
!recoverable(value$element_shape, declared$element_shape, depth + 1L, element = TRUE))) ||
(isTRUE(value$known_literal) && !identical(value$literal, declared$literal))) return(FALSE)
declared_names <- c(names(member_lookup(index$members, value$type)),
names(member_lookup(index$properties, value$type)),
names(member_lookup(index$raw_fields, value$type)), names(declared$fields))
all(vapply(names(value$fields), function(name) {
name %in% declared_names && recoverable(value$fields[[name]],
member_access(declared, name, index, list()), depth + 1L)
}, logical(1L)))
}
prepare <- function(item, limit) {
key <- item$key
type <- item$type
fn <- item$fn
env <- index$package_roots
for (name in names(fn[[2L]])) env[name] <- list(member_value())
if ("..." %in% names(fn[[2L]])) env["..."] <- list(member_value(type = "list", open = TRUE))
if (!is.null(type)) {
receiver <- member_lookup(index$method_receivers, paste(type, key, sep = "|"))
if (is.null(receiver)) receiver <- "self"
# Use only class guarantees, never a representative instance's fields.
env[receiver] <- list(member_value(type = type))
}
budget <- new.env(parent = emptyenv())
budget$remaining <- min(limit, state$remaining)
budget$exhausted <- budget$transient <- FALSE
before <- budget$remaining
result <- member_infer(fn[[3L]], preparation_index, env, budget = budget,
context = list(key = key, formals = names(fn[[2L]]), actuals = list()))
used <- before - budget$remaining
state$remaining <- state$remaining - used
if (!is.null(item$generic) && !budget$exhausted) {
candidate <- result
body <- fn[[3L]]
if (member_head(body, "{") && length(body) == 2L) body <- body[[2L]]
simple <- is.symbol(body) || member_head(body, "$") || member_head(body, "@")
if (!length(candidate$type) && simple && state$remaining > 0L) {
class <- substring(key, nchar(item$generic) + 2L)
if (class != "default") {
env[names(fn[[2L]])[[1L]]] <- list(member_value(type = class,
classes = member_lookup(index$classes, class)))
budget$remaining <- min(limit, state$remaining)
before <- budget$remaining
candidate <- member_infer(fn[[3L]], preparation_index, env, budget = budget,
context = list(key = key, formals = names(fn[[2L]]), actuals = list()))
state$remaining <- state$remaining - (before - budget$remaining)
}
}
if (!budget$exhausted && length(candidate$type) && !identical(candidate$type, ".never")) {
value <- if (length(candidate$type) == 1L && candidate$type %in% backed) {
member_value(type = candidate$type, classes = candidate$classes, member_package = index$package)
} else {
candidate
}
index$generic_returns[[item$generic]][key] <- list(value)
}
}
if (!budget$exhausted &&
!isTRUE(result$open) && length(result$type) == 1L && result$type %in% backed) {
# A wrapper may add instance fields beyond its declarative class.
# Keep full inference when the index cannot recover their shapes.
if (!recoverable(result, member_value(type = result$type))) return(FALSE)
id <- if (is.null(type)) key else paste(type, key, sep = "|")
# Native-backed declarative classes expose their members in the
# index. Argument-dependent fields must not enter a universal summary.
value <- member_value(type = result$type, classes = result$classes, member_package = index$package)
size <- as.numeric(utils::object.size(stats::setNames(list(value), id)))
if (state$bytes + size <= max_bytes) {
index$method_results[id] <- list(value)
state$bytes <- state$bytes + size
}
}
budget$exhausted
}
# Keep the existing expensive-default guarantees available to subsequent
# probes, but do not feed the new short-wrapper results back into analysis.
for (item in candidates) {
if (length(item$fn[[2L]]) < 10L) next
if (state$remaining <= 0L || state$bytes >= max_bytes) break
prepare(item, 10000L)
}
preparation_index$method_results <- index$method_results
candidates <- Filter(function(item) length(item$fn[[2L]]) < 10L, candidates)
# Finish exported factories and their S3 methods before large member
# registries consume the remaining budget with their initial probes.
for (exported in c(TRUE, FALSE)) {
group <- Filter(function(item) identical(is.null(item$type), exported), candidates)
unfinished <- list()
for (item in group) {
if (state$remaining <= 0L || state$bytes >= max_bytes) break
if (prepare(item, 64L)) unfinished[[length(unfinished) + 1L]] <- item
}
for (item in unfinished) {
if (state$remaining <= 0L || state$bytes >= max_bytes) break
prepare(item, 2048L)
}
}
# Suggestions describe known method outcomes, not a definite dispatch.
# Keep structural counterexamples so only their common members are offered.
for (generic in names(index$generic_returns)) {
values <- index$generic_returns[[generic]]
if (generic %in% index$generic_external || !any(vapply(values, function(value) any(value$type %in% backed), logical(1L)))) {
index$generic_returns[[generic]] <- NULL
} else {
index$generic_returns[[generic]] <- values[!duplicated(lapply(values, member_shape_key))]
}
}
if (as.numeric(utils::object.size(index$generic_returns)) > max_bytes) index$generic_returns <- list()
index$return_definitions <- digest::digest(index$definitions, algo = "xxhash64")
invisible(NULL)
}
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.