Interface ConfigQuery

Type declaration

• [key: string]: unknown

• Optional ReadonlyabstractInterpretation?: {
      dataFrame?: {
          maxColNames?: number;
          readLoadedData?: { maxReadLines?: number; readExternalFiles?: boolean };
          wideningThreshold?: number;
      };
  }

  Configuration options for abstract interpretation

  • Optional ReadonlydataFrame?: {
        maxColNames?: number;
        readLoadedData?: { maxReadLines?: number; readExternalFiles?: boolean };
        wideningThreshold?: number;
    }

    The configuration of the shape inference for data frames

    • Optional ReadonlymaxColNames?: number

      The maximum number of columns names to infer for data frames before over-approximating the column names to top

    • Optional ReadonlyreadLoadedData?: { maxReadLines?: number; readExternalFiles?: boolean }

      Configuration options for reading data frame shapes from loaded external data files, such as CSV files

      • Optional ReadonlymaxReadLines?: number

        The maximum number of lines to read when extracting data frame shapes from loaded files, such as CSV files

      • Optional ReadonlyreadExternalFiles?: boolean

        Whether data frame shapes should be extracted from loaded external data files, such as CSV files

    • Optional ReadonlywideningThreshold?: number

      The threshold for the number of visitations of a node at which widening should be performed to ensure the termination of the fixpoint iteration

• Optional ReadonlydefaultEngine?: "r-shell" | "tree-sitter"

  The default engine to use for interacting with R code. If this is undefined, an arbitrary engine from engines will be used.

• Optional Readonlyengines?: (
      | undefined
      | { rPath?: string; type?: "r-shell"; [key: string]: unknown }
      | {
          lax?: boolean;
          treeSitterWasmPath?: string;
          type?: "tree-sitter";
          wasmPath?: string;
          [key: string]: unknown;
      }
  )[]

  The engines to use for interacting with R code. Currently, supports TreeSitterEngineConfig and RShellEngineConfig. An empty array means all available engines will be used.

• Optional ReadonlyignoreSourceCalls?: boolean

  Whether source calls should be ignored, causing processSourceCall's behavior to be skipped

• Optional Readonlysemantics?: {
      environment?: {
          overwriteBuiltIns?: {
              definitions?: ((...) | (...) | (...) | (...))[];
              loadDefaults?: boolean;
          };
      };
  }

  Configure language semantics and how flowR handles them

  • Optional Readonlyenvironment?: {
        overwriteBuiltIns?: {
            definitions?: ((...) | (...) | (...) | (...))[];
            loadDefaults?: boolean;
        };
    }

    Semantics regarding the handling of the environment

    • Optional ReadonlyoverwriteBuiltIns?: { definitions?: ((...) | (...) | (...) | (...))[]; loadDefaults?: boolean }

      Do you want to overwrite (parts) of the builtin definition?

      • Optional Readonlydefinitions?: ((...) | (...) | (...) | (...))[]

        The definitions to load

      • Optional ReadonlyloadDefaults?: boolean

        Should the default configuration still be loaded?

• Optional Readonlysolver?: {
      evalStrings?: boolean;
      pointerTracking?: boolean | { maxIndexCount?: number };
      resolveSource?: {
          applyReplacements?: (undefined | { [key: string]: (...) | (...) })[];
          dropPaths?: DropPathsOption;
          ignoreCapitalization?: boolean;
          inferWorkingDirectory?: InferWorkingDirectory;
          repeatedSourceLimit?: number;
          searchPath?: (undefined | string)[];
          [key: string]: unknown;
      };
      slicer?: { threshold?: number };
      variables?: VariableResolve;
  }

  How to resolve constants, constraints, cells, …

  • Optional ReadonlyevalStrings?: boolean

    Should we include eval(parse(text="...")) calls in the dataflow graph?

  • Optional ReadonlypointerTracking?: boolean | { maxIndexCount?: number }

    Whether to track pointers in the dataflow graph, if not, the graph will be over-approximated wrt. containers and accesses

  • Optional ReadonlyresolveSource?: {
        applyReplacements?: (undefined | { [key: string]: (...) | (...) })[];
        dropPaths?: DropPathsOption;
        ignoreCapitalization?: boolean;
        inferWorkingDirectory?: InferWorkingDirectory;
        repeatedSourceLimit?: number;
        searchPath?: (undefined | string)[];
        [key: string]: unknown;
    }

    If lax source calls are active, flowR searches for sourced files much more freely, based on the configurations you give it. This option is only in effect if ignoreSourceCalls is set to false.

    • Optional ReadonlyapplyReplacements?: (undefined | { [key: string]: (...) | (...) })[]

      sometimes files may have a different name in the source call (e.g., due to later replacements), with this setting you can provide a list of replacements to apply for each sourced file. Every replacement consists of a record that maps a regex to a replacement string.

      Example

      [
           { }, // no replacement -> still try the original name/path
           { '.*\\.R$': 'main.R' }, // replace all .R files with main.R
           { '\s' : '_' }, // replace all spaces with underscores
           { '\s' : '-', 'oo': 'aa' }, // replace all spaces with dashes and oo with aa
      ]
      Copy

      Given a source("foo bar.R") this configuration will search for (in this order):

      • foo bar.R (original name)
      • main.R (replaced with main.R)
      • foo_bar.R (replaced spaces)
      • faa-bar.R (replaced spaces and oo)

    • Optional ReadonlydropPaths?: DropPathsOption

      Allow to drop the first or all parts of the sourced path, if it is relative.

    • Optional ReadonlyignoreCapitalization?: boolean

      search for filenames matching in the lowercase

    • Optional ReadonlyinferWorkingDirectory?: InferWorkingDirectory

      try to infer the working directory from the main or any script to analyze.

    • Optional ReadonlyrepeatedSourceLimit?: number

      How often the same file can be sourced within a single run? Please be aware: in case of cyclic sources this may not reach a fixpoint so give this a sensible limit.

    • Optional ReadonlysearchPath?: (undefined | string)[]

      Additionally search in these paths

  • Optionalslicer?: { threshold?: number }

    The configuration for flowR's slicer

    • Optional Readonlythreshold?: number

      The maximum number of iterations to perform on a single function call during slicing

  • Optional Readonlyvariables?: VariableResolve

    How to resolve variables and their values