Interface ReadOnlyFlowrAnalyzerDependenciesContext

ReadonlyfunctionsContext

Readonlyname

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[]

declaredPackageNames

• declaredPackageNames(): readonly BrandedNamespace[]

  Every package name the project declares (Depends/Imports/Suggests/LinkingTo/Enhances), whether or not it became a loadable dependency here. Suggests do not, yet they still name packages the project may install.

  Returns readonly BrandedNamespace[]

getDependencies

• getDependencies(): readonly Readonly<Package>[]

  Get all dependencies known to this context.

  Returns readonly Readonly<Package>[]

getDependency

• getDependency(
      name: BrandedNamespace,
      version?: string | Range,
  ): Readonly<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: BrandedNamespace

    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 Readonly<Package> | undefined

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

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

inferredRange

• inferredRange(name: BrandedNamespace): Range | undefined

  The versions a dependency can possibly have: its derived range, but only once some version can satisfy it. undefined if the dependency is unknown, if nothing constrains it, or if the sources contradict each other, since 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: BrandedNamespace

    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: BrandedIdentifier): readonly BrandedNamespace[]

  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: BrandedIdentifier

  Returns readonly BrandedNamespace[]

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 to FunctionSemantics.call.match.toNames. undefined if id is unqualified or no loaded source defines it.

  Parameters

  • id: Identifier
  • Optionalversion: string

  Returns DecodedFunction | undefined

  Use Instead

  SignatureDb.functionOf

signatures

• signatures(): SignatureDb

  The way to reach the signature database programmatically.

  Everything the database can answer is on the returned SignatureDb, and it answers for the version this project assumes for each package, which is the one solver.sigdb.versionOverrides, solver.sigdb.versionSelection and solver.sigdb.assumedRVersion produced. A bare PackageSignatureSource would instead answer for whatever it happens to hold as newest.

  Returns SignatureDb

  Example

  const db = analyzer.inspectContext().deps.signatures();
  db.versionOf('dplyr');                              // the version the analysis assumes
  db.functionOf(Identifier.make('lead', 'dplyr'));    // its database entry
  db.parametersOf(Identifier.make('lead', 'dplyr'));  // its formals, ready for FunctionSemantics.call.match.toNames
  Copy

signatureSources

• signatureSources(): readonly PackageSignatureSource[]

  The signature sources the version plugins currently have loaded, as they are. Prefer signatures, which is the same sources as one database with the versions already resolved.

  Returns readonly PackageSignatureSource[]