Class FlowrAnalyzerDependenciesContext

constructor

• new FlowrAnalyzerDependenciesContext(
      functionsContext: FlowrAnalyzerFunctionsContext,
      plugins?: readonly FlowrAnalyzerPackageVersionsPlugin[],
  ): FlowrAnalyzerDependenciesContext

  Parameters

  • functionsContext: FlowrAnalyzerFunctionsContext
  • Optionalplugins: readonly FlowrAnalyzerPackageVersionsPlugin[]

  Returns FlowrAnalyzerDependenciesContext

ReadonlyfunctionsContext

Readonlyname

addDatabaseSource

• addDatabaseSource(source: string): Promise<void>

  Mount an additional signature database/source by path (a plain .sigs.ndjson, a .br, or a manifest).

  Parameters

  • source: string

  Returns Promise<void>

addDeclaredDependency

• addDeclaredDependency(pkg: Package): this

  Register a dependency declared by a project metadata file (DESCRIPTION, renv.lock, rv.lock). Gated by solver.sigdb.loadProjectDependencies: when project-dependency loading is disabled this is a no-op, so the declared deps never enter the context (unlike addDependency, used for on-demand signature-database resolution).

  Parameters

  • pkg: Package

  Returns this

addDependency

• addDependency(pkg: Package): this

  Parameters

  • pkg: Package

  Returns this

addLazyResolver

• addLazyResolver(
      resolver: (name: string, existing?: Package) => Package | undefined,
  ): void

  Register a resolver consulted by getDependency to fill in a package's exports lazily.

  Parameters

  • resolver: (name: string, existing?: Package) => Package | undefined

  Returns void

availableSignatureDatabases

• availableSignatureDatabases(): readonly string[]

  The identifying names (scopes, e.g. base/current/history) of the signature databases currently available, deduplicated. A simple view over loadedSignatureDatabases for checking what a project can resolve against; empty when the signature database is disabled or none is loaded.

  Returns readonly string[]

baseRSourceFingerprint

• baseRSourceFingerprint(): string

  Cheap fingerprint of only the base-R-providing databases, so base-R-derived caches survive unrelated database changes.

  Returns string

eagerlyLoadSignatureDatabases

• eagerlyLoadSignatureDatabases(): void

  Eagerly mount every version plugin's signature database up front (see solver.sigdb.eagerlyLoad).

  Returns void

ensureStaticsLoaded

• ensureStaticsLoaded(): void

  Runs the static plugins once. They fill this context and the project metadata, so both gate their reads on it.

  Returns void

getDependencies

• getDependencies(): Package[]

  Get all dependencies known to this context.

  Returns Package[]

getDependency

• getDependency(name: string, version?: string | Range): Package | undefined

  Get the dependency with the given name, if it exists.

  If the static dependencies have not yet been loaded, this may trigger a resolution step. Pass version to pin the resolution to a constraint (an exact version string, or a Range; uncached; versionOverrides config still wins, base-R stays tied to the assumed R version); otherwise the version comes from the declared constraints.

  Parameters

  • name: string

    The name of the dependency to get.

  • Optionalversion: string | Range

    Optional version constraint to pin the resolution to (exact version string or a Range).

  Returns Package | undefined

  The dependency with the given name, or undefined if it does not exist.

hasBaseRSource

• hasBaseRSource(): boolean

  Whether any version plugin can resolve the base-R packages (a versioned signature source is available).

  Returns boolean

hasSignatureDatabase

• hasSignatureDatabase(): boolean

  Whether at least one signature database is available (i.e., availableSignatureDatabases is non-empty). Cheaper than materializing the list when only the presence matters.

  Returns boolean

inferredVersion

• inferredVersion(name: string): Range | undefined

  The versions a dependency can possibly have, combining everything declared for it (a DESCRIPTION range, an rproject.toml entry, a lockfile pin, ...). undefined if the dependency is unknown, if nothing constrains it, or if the sources contradict each other -- then no version is possible at all.

  For why it is what it is (the individual constraints, or the version the database resolved to), take the Package from getDependency.

  Parameters

  • name: string

    The name of the dependency.

  Returns Range | undefined

loadedSignatureDatabases

• loadedSignatureDatabases(): SigDbLoadedInfo[]

  Metadata of the signature databases the version plugins currently have loaded.

  Returns SigDbLoadedInfo[]

packagesExporting

• packagesExporting(name: string): readonly string[]

  The names of known packages that export name (from the version plugins' signature databases). Used to hint which library()/:: might be missing for an otherwise-undefined symbol. Empty if no database is available or the signature database is disabled.

  Parameters

  • name: string

  Returns readonly string[]

reset

• reset(): void

  Reset the context to its initial state.

  Returns void

resolveStaticDependencies

• resolveStaticDependencies(): void

  Returns void

signatureOf

• signatureOf(id: Identifier, version?: string): DecodedFunction | undefined

  The signature-database entry for the qualified call id (a pkg::fn Identifier) from the first source that has it, resolving the package version from the project's dependency info unless version overrides it. This is the easy way to obtain a function's parameters from a context: pass fn.signature (or signatureParameterNames) to RFunctionCall.matchArgsToParams. undefined if id is unqualified or no loaded source defines it.

  Parameters

  • id: Identifier
  • Optionalversion: string

  Returns DecodedFunction | undefined

signatureSources

• signatureSources(): readonly PackageSignatureSource[]

  The signature sources the version plugins currently have loaded (backs the signature query).

  Returns readonly PackageSignatureSource[]