@eagleoutice/flowr - v2.15.9
    Preparing search index...

    Interface FlowrConfig

    The configuration file format for flowR.

    interface FlowrConfig {
        abstractInterpretation: {
            dataFrame: {
                maxColNames: number;
                readLoadedData: { maxReadLines: number; readExternalFiles: boolean };
            };
            followCalls: boolean;
            wideningThreshold: number;
        };
        defaultEngine?: "r-shell"
        | "tree-sitter";
        defaultPlugins: ConfigPlugin<string>[];
        engines: EngineConfig[];
        gas: FlowrGasConfig;
        ignoreLoadCalls: boolean;
        ignoreSourceCalls: boolean;
        incremental: {
            alwaysIncremental: boolean;
            parsing: {
                activated: boolean;
                heuristics: {
                    activated: boolean;
                    alwaysWithEdits: boolean;
                    bytesFrom: number;
                    linesFrom: number;
                    minFiles: number;
                    mtime: boolean;
                };
            };
        };
        inputSources?: {
            cmdline?: string[];
            const?: string[];
            dconst?: string[];
            ffi?: string[];
            file?: string[];
            glob?: string[];
            lang?: string[];
            linkedEntryPoints?: { argIdx: ...; argName: ...; call: ...; params: ... }[];
            linkedObjects?: {
                declaredBy?: ...;
                fields?: ...;
                name: ...;
                requires?: ...;
                type: ...;
                withParams?: ...;
            }[];
            narrowing?: { argIdx?: ...; argName?: ...; call: ... }[];
            net?: string[];
            options?: string[];
            param?: string[];
            pure?: string[];
            rand?: string[];
            scope?: string[];
            system?: string[];
            tempfile?: string[];
            unknown?: string[];
            user?: string[];
        };
        linter: { disabledRules: string[] };
        logLevel?:
            | "debug"
            | "silly"
            | "trace"
            | "info"
            | "warn"
            | "error"
            | "fatal";
        project: {
            assumeImplicitEcho?: boolean;
            basePackages?: string[];
            classification?: {
                notebookExtensions?: (...)[];
                shinyDescriptionTypes?: (...)[];
                shinyEntryFiles?: (...)[];
                shinyUsagePattern?: string;
            };
            discovery?: { full?: boolean; ignore?: (...)[]; perKind?: Partial<(...)> };
            failOnInaccessiblePath?: boolean;
            implicitSources?: string[];
            resolveUnknownPathsOnDisk: boolean;
            useProjectType?: ProjectKind;
        };
        repl: {
            autoUseFileProtocol?: boolean;
            dfProcessorHeat: boolean;
            hints: boolean;
            plugins: ConfigPlugin<string>[];
            queryStats?: boolean;
            quickStats: boolean;
            showPlugins?: boolean;
        };
        semantics: {
            environment: {
                overwriteBuiltIns: {
                    definitions: BuiltInDefinition<(...)>[];
                    loadDefaults?: boolean;
                };
            };
        };
        solver: {
            assumeAttachedPackages?: string[];
            evalStrings: boolean;
            instrument: {
                dataflowExtractors?: (
                    extractor: DataflowProcessors<(...)>,
                    ctx: FlowrAnalyzerContext,
                ) => DataflowProcessors<(...)>;
            };
            maxOverlayDepth?: number;
            resolveSource?: FlowrLaxSourcingOptions;
            sigdb: {
                additionalPaths?: string[];
                assumedRVersion?: string;
                autoSync?: boolean;
                blobCacheBudgetMb?: number;
                downloadRepo?: string;
                eagerlyLoad: boolean;
                eagerlyLoadExports: boolean;
                enabled: boolean;
                installedLibrary?: {
                    enabled: boolean;
                    maxDepth?: (...)
                    | (...);
                    packages?: (...) | (...);
                    paths?: (...) | (...);
                    useEnvironment?: (...) | (...) | (...);
                    useProjectLibrary?: (...) | (...) | (...);
                };
                linkBaseR: boolean;
                linkBaseRCalls?: boolean;
                linkDescriptionDependencies: boolean;
                linkPackageCalls?: boolean;
                loadProjectDependencies: boolean;
                versionOverrides?: Record<string, string>;
                versionSelection?: VersionSelection;
                warmInBackground?: boolean;
            };
            slicer?: { autoExtend?: boolean; threshold?: number };
            trackEnvironments: boolean;
            transitiveSideEffectRounds?: number;
            variables: VariableResolve;
            versionManagement?: { linkedVersionGroups?: (...)[] };
        };
        specializeConfig?: Partial<Record<ProjectKind, SpecializeConfigEntry>>;
    }
    Index
    abstractInterpretation defaultEngine? defaultPlugins engines gas ignoreLoadCalls ignoreSourceCalls incremental inputSources? linter logLevel? project repl semantics solver specializeConfig?
    abstractInterpretation: {
        dataFrame: {
            maxColNames: number;
            readLoadedData: { maxReadLines: number; readExternalFiles: boolean };
        };
        followCalls: boolean;
        wideningThreshold: number;
    }
    defaultEngine?: "r-shell" | "tree-sitter"

    The default engine to use. If undefined, an arbitrary one from engines is used.

    defaultPlugins: ConfigPlugin<string>[]
    engines: EngineConfig[]

    Engines to use for interacting with R code (TreeSitterEngineConfig, RShellEngineConfig); empty means all available engines.

    gas: FlowrGasConfig

    Resource-usage guard (gas) configuration; disabled by default (every feature factor 0), enable by setting a feature's factor > 0. See FlowrGasConfig, ReadOnlyFlowrAnalyzerGasContext.

    ignoreLoadCalls: boolean
    ignoreSourceCalls: boolean
    incremental: {
        alwaysIncremental: boolean;
        parsing: {
            activated: boolean;
            heuristics: {
                activated: boolean;
                alwaysWithEdits: boolean;
                bytesFrom: number;
                linesFrom: number;
                minFiles: number;
                mtime: boolean;
            };
        };
    }
    inputSources?: {
        cmdline?: string[];
        const?: string[];
        dconst?: string[];
        ffi?: string[];
        file?: string[];
        glob?: string[];
        lang?: string[];
        linkedEntryPoints?: { argIdx: ...; argName: ...; call: ...; params: ... }[];
        linkedObjects?: {
            declaredBy?: ...;
            fields?: ...;
            name: ...;
            requires?: ...;
            type: ...;
            withParams?: ...;
        }[];
        narrowing?: { argIdx?: ...; argName?: ...; call: ... }[];
        net?: string[];
        options?: string[];
        param?: string[];
        pure?: string[];
        rand?: string[];
        scope?: string[];
        system?: string[];
        tempfile?: string[];
        unknown?: string[];
        user?: string[];
    }

    Teaches the InputSourcesQuery|input-sources analysis further frameworks; entries are added to what flowR knows already. Usually set per ProjectKind via specializeConfig. See InputClassifierConfig.

    Type Declaration

    • Optionalcmdline?: string[]
    • Optionalconst?: string[]
    • Optionaldconst?: string[]
    • Optionalffi?: string[]
    • Optionalfile?: string[]
    • Optionalglob?: string[]
    • Optionallang?: string[]
    • OptionallinkedEntryPoints?: { argIdx: ...; argName: ...; call: ...; params: ... }[]

      Calls that hand a function to a framework, which then binds linkedObjects to its parameters by position.

      LinkedInputEntryPoint

    • OptionallinkedObjects?: {
          declaredBy?: ...;
          fields?: ...;
          name: ...;
          requires?: ...;
          type: ...;
          withParams?: ...;
      }[]

      Objects provided by a framework rather than by the code itself, like shiny's input.

      LinkedInputObject

    • Optionalnarrowing?: { argIdx?: ...; argName?: ...; call: ... }[]

      Functions whose result is bounded by one of their arguments (classified by that argument alone).

      NarrowingFunction

    • Optionalnet?: string[]
    • Optionaloptions?: string[]
    • Optionalparam?: string[]
    • Optionalpure?: string[]

      Functions which are considered to be pure (i.e., deterministic, trusted, safe, idempotent on the lub of the input types)

    • Optionalrand?: string[]
    • Optionalscope?: string[]
    • Optionalsystem?: string[]
    • Optionaltempfile?: string[]
    • Optionalunknown?: string[]
    • Optionaluser?: string[]
    linter: { disabledRules: string[] }
    logLevel?: "debug" | "silly" | "trace" | "info" | "warn" | "error" | "fatal"
    project: {
        assumeImplicitEcho?: boolean;
        basePackages?: string[];
        classification?: {
            notebookExtensions?: (...)[];
            shinyDescriptionTypes?: (...)[];
            shinyEntryFiles?: (...)[];
            shinyUsagePattern?: string;
        };
        discovery?: { full?: boolean; ignore?: (...)[]; perKind?: Partial<(...)> };
        failOnInaccessiblePath?: boolean;
        implicitSources?: string[];
        resolveUnknownPathsOnDisk: boolean;
        useProjectType?: ProjectKind;
    }

    Type Declaration

    • OptionalassumeImplicitEcho?: boolean

      Whether the top level's visible results count as an output (the print category); off by default for a ProjectKind.Package, whose top level runs at install time.

    • OptionalbasePackages?: string[]

      The packages considered part of R itself; if unset, flowR derives them (for the assumed R version) from the signature database via baseRPackages.

    • Optionalclassification?: {
          notebookExtensions?: (...)[];
          shinyDescriptionTypes?: (...)[];
          shinyEntryFiles?: (...)[];
          shinyUsagePattern?: string;
      }
      • OptionalnotebookExtensions?: (...)[]

        File extensions marking a notebook (default ipynb, rmd, rmarkdown, qmd, rnw).

      • OptionalshinyDescriptionTypes?: (...)[]

        DESCRIPTION Type: values that mark a shiny app (default shiny, shiny-app, shinyapp).

      • OptionalshinyEntryFiles?: (...)[]

        File names a shiny app is assembled from (default app.R, ui.R, server.R, global.R).

      • OptionalshinyUsagePattern?: string
    • Optionaldiscovery?: { full?: boolean; ignore?: (...)[]; perKind?: Partial<(...)> }
    • OptionalfailOnInaccessiblePath?: boolean
    • OptionalimplicitSources?: string[]
    • resolveUnknownPathsOnDisk: boolean
    • OptionaluseProjectType?: ProjectKind
    repl: {
        autoUseFileProtocol?: boolean;
        dfProcessorHeat: boolean;
        hints: boolean;
        plugins: ConfigPlugin<string>[];
        queryStats?: boolean;
        quickStats: boolean;
        showPlugins?: boolean;
    }

    Type Declaration

    • OptionalautoUseFileProtocol?: boolean

      Automatically use the file protocol for inputs that look like paths (default true)

    • dfProcessorHeat: boolean
    • hints: boolean

      Whether to show dim inline hints (e.g. :help) on the empty prompt; automatically disabled on non-interactive terminals

    • plugins: ConfigPlugin<string>[]
    • OptionalqueryStats?: boolean

      Whether :query closes with the line stating how long the queries took (default true, :query* never prints it)

    • quickStats: boolean
    • OptionalshowPlugins?: boolean

      Whether :version grays out the plugins that did not activate during the last analysis (default false)

    semantics: {
        environment: {
            overwriteBuiltIns: {
                definitions: BuiltInDefinition<(...)>[];
                loadDefaults?: boolean;
            };
        };
    }
    solver: {
        assumeAttachedPackages?: string[];
        evalStrings: boolean;
        instrument: {
            dataflowExtractors?: (
                extractor: DataflowProcessors<(...)>,
                ctx: FlowrAnalyzerContext,
            ) => DataflowProcessors<(...)>;
        };
        maxOverlayDepth?: number;
        resolveSource?: FlowrLaxSourcingOptions;
        sigdb: {
            additionalPaths?: string[];
            assumedRVersion?: string;
            autoSync?: boolean;
            blobCacheBudgetMb?: number;
            downloadRepo?: string;
            eagerlyLoad: boolean;
            eagerlyLoadExports: boolean;
            enabled: boolean;
            installedLibrary?: {
                enabled: boolean;
                maxDepth?: (...)
                | (...);
                packages?: (...) | (...);
                paths?: (...) | (...);
                useEnvironment?: (...) | (...) | (...);
                useProjectLibrary?: (...) | (...) | (...);
            };
            linkBaseR: boolean;
            linkBaseRCalls?: boolean;
            linkDescriptionDependencies: boolean;
            linkPackageCalls?: boolean;
            loadProjectDependencies: boolean;
            versionOverrides?: Record<string, string>;
            versionSelection?: VersionSelection;
            warmInBackground?: boolean;
        };
        slicer?: { autoExtend?: boolean; threshold?: number };
        trackEnvironments: boolean;
        transitiveSideEffectRounds?: number;
        variables: VariableResolve;
        versionManagement?: { linkedVersionGroups?: (...)[] };
    }

    Type Declaration

    • Optional ReadonlyassumeAttachedPackages?: string[]

      Packages to treat as attached without a library() call, on top of the base packages R attaches on startup (see AttachedBasePackages, which a bare name resolves against without this option).

    • ReadonlyevalStrings: boolean
    • Readonlyinstrument: {
          dataflowExtractors?: (
              extractor: DataflowProcessors<(...)>,
              ctx: FlowrAnalyzerContext,
          ) => DataflowProcessors<(...)>;
      }
      • OptionaldataflowExtractors?: (
            extractor: DataflowProcessors<(...)>,
            ctx: FlowrAnalyzerContext,
        ) => DataflowProcessors<(...)>

        Modify the dataflow processors used during analysis; keep every processor correctness requires present. May affect precision/performance arbitrarily -- prefer decorating existing processors over replacing them.

    • Optional ReadonlymaxOverlayDepth?: number

      How many binding overlays may stack on one environment frame before a write flattens them (default DefaultMaxOverlayDepth); trades lookup cost against copy cost and never changes a result.

    • Optional ReadonlyresolveSource?: FlowrLaxSourcingOptions
    • Readonlysigdb: {
          additionalPaths?: string[];
          assumedRVersion?: string;
          autoSync?: boolean;
          blobCacheBudgetMb?: number;
          downloadRepo?: string;
          eagerlyLoad: boolean;
          eagerlyLoadExports: boolean;
          enabled: boolean;
          installedLibrary?: {
              enabled: boolean;
              maxDepth?: (...) | (...);
              packages?: (...) | (...);
              paths?: (...) | (...);
              useEnvironment?: (...) | (...) | (...);
              useProjectLibrary?: (...) | (...) | (...);
          };
          linkBaseR: boolean;
          linkBaseRCalls?: boolean;
          linkDescriptionDependencies: boolean;
          linkPackageCalls?: boolean;
          loadProjectDependencies: boolean;
          versionOverrides?: Record<string, string>;
          versionSelection?: VersionSelection;
          warmInBackground?: boolean;
      }
      • Optional ReadonlyadditionalPaths?: string[]
      • Optional ReadonlyassumedRVersion?: string

        R version assumed when resolving versioned (base-R) exports: a pin, or "auto" to detect the installed R (falling back to DefaultAssumedRVersion if none, e.g. tree-sitter). See resolveAssumedRVersion.

      • Optional ReadonlyautoSync?: boolean
      • Optional ReadonlyblobCacheBudgetMb?: number

        How many MiB of decoded package blobs every open bundle may hold together; a bigger budget re-reads and re-parses less, a smaller one keeps less in memory (default 16).

      • Optional ReadonlydownloadRepo?: string
      • ReadonlyeagerlyLoad: boolean
      • ReadonlyeagerlyLoadExports: boolean
      • Readonlyenabled: boolean
      • Optional ReadonlyinstalledLibrary?: {
            enabled: boolean;
            maxDepth?: (...) | (...);
            packages?: (...) | (...);
            paths?: (...) | (...);
            useEnvironment?: (...) | (...) | (...);
            useProjectLibrary?: (...) | (...) | (...);
        }

        Recovering a package no signature database knows (e.g. maptools) from its local install: DESCRIPTION states the version, NAMESPACE the exports. Opt-in, since it reads outside the analyzed project.

      • ReadonlylinkBaseR: boolean

        Eagerly attach base-R namespaces (from a signature database) so bare base calls resolve without library() (default false; changes every analysis; needs a base-R signature database).

      • Optional ReadonlylinkBaseRCalls?: boolean

        Add a lightweight Reads edge from a bare base-R call to its signature-database function vertex (built-in:pkg:fn); base-R qualification stays edge-free unless this is on (default false; adds edges to every base call).

      • ReadonlylinkDescriptionDependencies: boolean

        Eagerly attach the namespaces of the project's declared DESCRIPTION dependencies (Imports/Depends) so their exports resolve without an explicit library() (default false; changes every analysis; needs a signature database resolving the declared packages).

      • Optional ReadonlylinkPackageCalls?: boolean

        Add a lightweight Reads edge from a resolved package call (pkg::fn/attached export) to its signature-database function vertex (default false).

      • ReadonlyloadProjectDependencies: boolean
      • Optional ReadonlyversionOverrides?: Record<string, string>

        Force an exact version for specific packages (mapping a package name to a version), overriding both the project constraint and the versionSelection policy; a version missing from the database falls back with a warning (default {}).

      • Optional ReadonlyversionSelection?: VersionSelection
      • Optional ReadonlywarmInBackground?: boolean

        Decompress the hot shards (base + most-downloaded) in a background task on startup, so the first library() lookup is warm (default false; useful for long-running servers/REPLs, not one-shot runs).

    • Optionalslicer?: { autoExtend?: boolean; threshold?: number }
    • ReadonlytrackEnvironments: boolean
    • Optional ReadonlytransitiveSideEffectRounds?: number
    • Readonlyvariables: VariableResolve
    • Optional ReadonlyversionManagement?: { linkedVersionGroups?: (...)[] }
    specializeConfig?: Partial<Record<ProjectKind, SpecializeConfigEntry>>

    Overwrite (parts of) this configuration per ProjectKind; an entry may inherit another kind's overwrite first (own keys win). Resolve with FlowrConfig.forKind.

    Settings
    Member Visibility

    On This Page
    Properties