Variable LintingRulesConst

Type Declaration

• Readonlyabsolute-file-paths: {
      createSearch: (
          config: AbsoluteFilePathConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => FlowrSearchBuilderOut<"from-query", [], ParentInformation, "unique">;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              absolutePathRegex: ...;
              additionalPathFunctions: ...;
              ignoreUrls: ...;
              include: ...;
              useAsWd: ...;
          };
          description: "Finds absolute file paths.";
          name: "Absolute Paths";
          tags: readonly [Robustness, Reproducibility, Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: AbsoluteFilePathResult) => string;
          query: (result: AbsoluteFilePathResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: AbsoluteFilePathConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlybogus-return: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: Exact;
          defaultConfig: () => {};
          description: "Finds a bare `return` (without `()`), which evaluates to the function `return` instead of returning. Offers `return()` as a quick fix.";
          name: "Bogus Return";
          tags: readonly [CmdCheck, Bug, QuickFix];
      };
      prettyPrint: {
          full: (r: BogusReturnResult) => string;
          query: (r: BogusReturnResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: MergeableRecord,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlycall-arguments: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              checkPackageFunctions: ...;
              reportPartialMatches: ...;
          };
          description: "Finds calls with arguments the called function does not take, names that match a formal only partially or match several formals, `...` used in a function without `...`, and local functions defined twice with different formals. Calls are resolved through the dataflow graph.";
          name: "Call Arguments";
          tags: readonly [CmdCheck, Bug, Robustness, QuickFix];
      };
      prettyPrint: {
          full: (r: CallArgumentsResult) => string;
          query: (r: CallArgumentsResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: CallArgumentsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyclass-string-comparison: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { checkWhile: ...; resolveStrings: ... };
          description: "Finds `if`/`while` conditions comparing `class(x)` with a string, which fail for objects with several classes. Offers `inherits(x, ...)` as a quick fix.";
          name: "Class String Comparison";
          tags: readonly [CmdCheck, Bug, Robustness, QuickFix];
      };
      prettyPrint: {
          full: (r: ClassStringComparisonResult) => string;
          query: (r: ClassStringComparisonResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: ClassStringComparisonConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlycompiled-code: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              allowedFlags: ...;
              checkNonApi: ...;
              checkRegistration: ...;
              extraNonApiEntryPoints: ...;
              flagStarKinds: ...;
              headerPackages: ...;
              knownCxxStandards: ...;
              nonPortableFlags: ...;
              obsoleteCxxStandards: ...;
              skip: ...;
              unportableCalls: ...;
              unportableFortran: ...;
              unportableObjects: ...;
          };
          description: "Finds problems in `src/` and the build files: non-portable Makevars flags, BLAS/LAPACK and OpenMP flag use, GNU make extensions, pragmas, line endings, Fortran KIND, the C++ standard, calls to non-API or non-portable entry points, and `useDynLib` against `src/`.";
          name: "Compiled Code";
          tags: readonly [CmdCheck];
      };
      prettyPrint: {
          full: (result: CompiledCodeResult) => string;
          query: (result: CompiledCodeResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: CompiledCodeConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": { consideredFiles: ... }; results: (...)[] };
  }

• Readonlydataframe-access-validation: {
      createSearch: () => FlowrSearchBuilder<
          "all",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { readLoadedData: ... };
          description: "Finds accesses to columns and rows a data frame does not have.";
          name: "Dataframe Access Validation";
          tags: readonly [Bug, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: DataFrameAccessValidationResult) => string;
          query: (result: DataFrameAccessValidationResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: DataFrameAccessValidationConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlydead-code: {
      createSearch: (
          config: DeadCodeConfig,
      ) => FlowrSearchBuilderOut<"all", [(...)], ParentInformation, "filter">;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {};
          description: "Finds code that is never reached during execution.";
          name: "Dead Code";
          tags: readonly [Smell, Usability, Reproducibility, QuickFix];
      };
      prettyPrint: {
          full: (result: LintingResult) => string;
          query: (result: LintingResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: DeadCodeConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ results: ... }>;
  }

• Readonlydependency-declaration: {
      createSearch: () => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              checkAvailability: ...;
              checkOtherCode: ...;
              headerOnlyPackages: ...;
              ignoreWithin: ...;
              reportDependsNotImported: ...;
              reportLibraryCalls: ...;
          };
          description: "Finds packages the code, tests, examples, or vignettes use without the DESCRIPTION declaring them, Imports nothing imports from, `library()` calls in package code, own `:::` calls, and undeclared VignetteBuilder or RdMacros packages. Package names are resolved through variables.";
          name: "Dependency Declaration";
          tags: readonly [CmdCheck, Bug, Reproducibility];
      };
      prettyPrint: {
          full: (r: DependencyDeclarationResult) => string;
          query: (r: DependencyDeclarationResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: DependencyDeclarationConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlydeprecated-functions: {
      createSearch: (
          _config: DeprecatedFunctionsConfig,
      ) => FlowrSearchBuilderOut<"all", [(...)], ParentInformation, "with">;
      info: {
          certainty: BestEffort;
          defaultConfig: (
              ctx: ReadOnlyFlowrAnalyzerContext,
          ) => { always: ...; conditionally: ... };
          description: "Finds deprecated functions and deprecated arguments of still-current functions, offering the replacement as a quick fix where one is known. A call to a bare name whose package the code never attaches is reported as uncertain, as any function of that name would answer to it.";
          name: "Deprecated Functions";
          tags: readonly [Deprecated, Smell, Usability, Reproducibility, QuickFix];
      };
      prettyPrint: {
          full: (result: DeprecatedFunctionRuleResult) => string;
          query: (result: DeprecatedFunctionRuleResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: DeprecatedFunctionsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlydescription-metadata: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              cranIncoming: ...;
              maxDepends: ...;
              maxImports: ...;
          };
          description: "Finds problems in the DESCRIPTION: required fields, package name, version, maintainer, dependency fields, license, Authors@R, encoding, and the Title and Description style CRAN asks for.";
          name: "Description Metadata";
          tags: readonly [CmdCheck];
      };
      prettyPrint: {
          full: (r: { loc: ...; message: ... }) => string;
          query: (r: { loc: ...; message: ... }) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: DescriptionMetadataConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": ...; results: ... } | { ".meta": ...; results: ... };
  }

• Readonlydocumentation-mismatch: {
      createSearch: () => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              checkCodoc: ...;
              checkDefaults: ...;
              checkInternalUsage: ...;
              checkUndocumented: ...;
              checkUsage: ...;
              requireDocumentation: ...;
          };
          description: "Finds exported objects without documentation, functions whose formals differ from their `\\usage`, and arguments missing from or extra in `\\arguments`.";
          name: "Documentation Mismatch";
          tags: readonly [CmdCheck, Documentation, Bug];
      };
      prettyPrint: {
          full: (result: DocumentationMismatchResult) => string;
          query: (result: DocumentationMismatchResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: DocumentationMismatchConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyfile-path-validity: {
      createSearch: (
          config: FilePathValidityConfig,
      ) => FlowrSearchBuilderOut<"from-query", [], ParentInformation, "with">;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              additionalReadFunctions: ...;
              additionalWriteFunctions: ...;
              checkUrls: ...;
              includeUnknown: ...;
          };
          description: "Finds file paths used in read and write operations that are invalid or do not point to existing files.";
          name: "File Path Validity";
          tags: readonly [Robustness, Reproducibility, Bug, QuickFix];
      };
      prettyPrint: {
          full: (result: FilePathValidityResult) => string;
          query: (result: FilePathValidityResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: FilePathValidityConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyforeign-function-calls: {
      createSearch: () => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { resolveValues: ... };
          description: "Finds problems in `.Call`, `.C`, `.External`, and `.Fortran` calls: a missing or empty `PACKAGE`, calls into base or other packages, and undeclared packages. Routine and package names are resolved through variables.";
          name: "Foreign Function Calls";
          tags: readonly [CmdCheck, Bug, Robustness];
      };
      prettyPrint: {
          full: (r: ForeignFunctionCallsResult) => string;
          query: (r: ForeignFunctionCallsResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: ForeignFunctionCallsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyglobal-environment-modification: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { allowedGlobals: ...; checkSuperAssignments: ... };
          description: "Finds code that changes the global environment: `assign()` or `data()` into it, `attach()`, `<<-` without a binding in an enclosing function, and `<<-` to a package variable, whose binding is locked at run time.";
          name: "Global Environment Modification";
          tags: readonly [CmdCheck, Bug, Robustness];
      };
      prettyPrint: {
          full: (r: GlobalEnvironmentModificationResult) => string;
          query: (r: GlobalEnvironmentModificationResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: GlobalEnvironmentModificationConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlynamespace-access: {
      createSearch: (
          _config: NamespaceAccessConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {};
          description: "Finds `pkg:::name` where `name` is actually exported by `pkg` (so `::` would do), and `pkg::name` where the signature database knows `name` is not exported (which fails at runtime in R). Stays silent whenever the database has no definite answer for the name.";
          name: "Namespace Access Validity";
          tags: readonly [Bug, QuickFix];
      };
      prettyPrint: {
          full: (result: NamespaceAccessResult) => string;
          query: (result: NamespaceAccessResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: MergeableRecord,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": { unresolved: ... }; results: (...)[] };
  }

• Readonlynamespace-tampering: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { checkInternal: ... };
          description: "Finds `unlockBinding()` and `assignInNamespace()` on other namespaces, `.Internal()` calls, and `library.dynam()` given a file extension.";
          name: "Namespace Tampering";
          tags: readonly [Smell, CmdCheck, Robustness, Security];
      };
      prettyPrint: {
          full: (r: NamespaceTamperingResult) => string;
          query: (r: NamespaceTamperingResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: NamespaceTamperingConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlynaming-convention: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          activeByDefault: false;
          certainty: OverApproximative;
          defaultConfig: () => { caseing: ...; ignoreNonAlpha: ... };
          description: "Finds symbols that do not follow the naming convention of the code.";
          name: "Naming Convention";
          tags: readonly [Style, QuickFix];
      };
      prettyPrint: {
          full: (result: NamingConventionResult) => string;
          query: (result: NamingConventionResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: NamingConventionConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlynetwork-functions: {
      createSearch: (
          config: NetworkFunctionsConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          [(...), (...)],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: (ctx: ReadOnlyFlowrAnalyzerContext) => { fns: ... };
          description: "Finds functions that execute network operations, such as downloading files or making HTTP requests.";
          name: "Network Functions";
          tags: readonly [Reproducibility, Security, Performance, Smell];
      };
      prettyPrint: {
          full: (result: FunctionsResult) => string;
          query: (result: FunctionsResult) => string;
      };
      processSearchResult: (
          e: FlowrSearchElements<ParentInformation, (...)[]>,
          c: NetworkFunctionsConfig,
          d: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyno-leaked-credentials: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              credentialCallPattern: ...;
              credentialNamePattern: ...;
              credentialValuePattern: ...;
          };
          description: "Finds hardcoded credentials assigned to variables or passed as arguments whose names suggest they hold passwords, tokens, or API keys, handed to authentication functions, or whose values match known credential formats (AWS, GitHub, Slack, Stripe, Google, JWT, SSH, URLs with passwords).";
          name: "No Leaked Credentials";
          tags: readonly [Security, Experimental, Smell];
      };
      prettyPrint: {
          full: (result: NoLeakedCredentialsResult) => string;
          query: (result: NoLeakedCredentialsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: NoLeakedCredentialsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlynon-ascii-code: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { checkStrings: ...; checkSymbols: ... };
          description: "Finds non-ASCII characters in R code and the NAMESPACE outside of comments. Offers `\\u` escapes for strings as a quick fix.";
          name: "Non-ASCII Code";
          tags: readonly [Smell, CmdCheck, QuickFix];
      };
      prettyPrint: {
          full: (r: NonAsciiCodeResult) => string;
          query: (r: NonAsciiCodeResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: NonAsciiCodeConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": { consideredTokens: ... }; results: (...)[] };
  }

• Readonlypackage-data: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              checkCompaction: ...;
              checkUndocumented: ...;
              maxUncompressedSize: ...;
          };
          description: "Finds problems in `data/` and `R/sysdata.rda`: allowed file types, LazyData, compression, the serialization version R needs, and undocumented data sets.";
          name: "Package Data";
          tags: readonly [CmdCheck];
      };
      prettyPrint: {
          full: (r: { loc: ...; message: ... }) => string;
          query: (r: { loc: ...; message: ... }) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: PackageDataConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => {
          ".meta": { inspectedDataFiles: ...; onDisk: ... };
          results: (...)[];
      };
  }

• Readonlypackage-hooks: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              allowedOutput: ...;
              followCalls: ...;
              startupMessageFunctions: ...;
              unsafeCalls: ...;
          };
          description: "Finds problems in `.onLoad`, `.onAttach`, `.onDetach`, and `.Last.lib`: argument lists, attaching packages, output other than `packageStartupMessage()`, `installed.packages()`, misplaced `library.dynam()` calls, and the obsolete `.First.lib`. Follows calls into the package's own functions.";
          name: "Package Hooks";
          tags: readonly [CmdCheck, Bug, Usability, QuickFix];
      };
      prettyPrint: {
          full: (r: PackageHooksResult) => string;
          query: (r: PackageHooksResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: PackageHooksConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlypackage-metafiles: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              citation: ...;
              index: ...;
              relativeLinks: ...;
              superseded: ...;
          };
          description: "Finds problems in the demo index, `INDEX`, `inst/CITATION`, and relative links in README, NEWS, and vignettes.";
          name: "Package Metafiles";
          tags: readonly [CmdCheck, Robustness];
      };
      prettyPrint: {
          full: (result: PackageMetafilesResult) => string;
          query: (result: PackageMetafilesResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: PackageMetafilesConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": { checkedFiles: ... }; results: (...)[] };
  }

• Readonlypackage-runtime: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { checkWrites: ... };
          description: "Finds what makes installing, loading, or running the package fail without doing so: undefined exports, S3 methods without a function, bad NAMESPACE imports, a package attaching itself, tests that never run, test or vignette code that does not parse, missing vignette metadata, and files written into the working directory.";
          name: "Package Runtime";
          tags: readonly [CmdCheck, Bug, Robustness];
      };
      prettyPrint: {
          full: (r: PackageRuntimeResult) => string;
          query: (r: PackageRuntimeResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: PackageRuntimeConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlypackage-structure: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              builtPackage: ...;
              checkBashisms: ...;
              checkFutureTimestamps: ...;
              checkTopLevel: ...;
              cranKnownHidden: ...;
              cranPack: ...;
              docDirsNotInstalled: ...;
              hiddenAllowed: ...;
              leftoverExtensions: ...;
              maxInstalledSizeMb: ...;
              maxPathLength: ...;
              maxPdfBytes: ...;
              reservedInstDirs: ...;
              standardTopLevel: ...;
          };
          description: "Finds problems in the package files: portable names, hidden files, top-level files, subdirectories, permissions, executables, timestamps, sizes, line endings of scripts, and vignette leftovers.";
          name: "Package Structure";
          tags: readonly [CmdCheck];
      };
      prettyPrint: {
          full: (r: { loc: ...; message: ... }) => string;
          query: (r: { loc: ...; message: ... }) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: PackageStructureConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": { inspectedEntries: ...; onDisk: ... }; results: (...)[] };
  }

• Readonlyproblematic-inputs: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [(...)],
          ParentInformation,
          "with",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: (
              ctx: ReadOnlyFlowrAnalyzerContext,
          ) => { consider: ...; pipeCommandFunctions: ... };
          description: "Finds dynamic calls (e.g. eval, system) with non-constant inputs, and graphics-device calls (pdf, postscript) where a filename starts with '|' indicating a pipe command injection.";
          name: "Problematic Inputs";
          tags: readonly [Security, Smell, Readability, Performance];
      };
      prettyPrint: {
          full: (result: ProblematicInputsResult) => string;
          query: (result: ProblematicInputsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: ProblematicInputsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ results: ... }>;
  }

• Readonlyrd-files: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              bibentries: ...;
              contents: ...;
              crossReferences: ...;
              docStyle: ...;
              examples: ...;
              examplesWidth: ...;
              extraMacros: ...;
              keywords: ...;
              lineWidths: ...;
              metadata: ...;
              minLevel: ...;
              parse: ...;
              requireValue: ...;
              standardKeywords: ...;
              uncertainLinks: ...;
              usageWidth: ...;
          };
          description: "Finds problems in the Rd files: syntax, unknown macros, required and duplicated sections, metadata, cross-references, line widths, contents, and the example code.";
          name: "Rd Files";
          tags: readonly [CmdCheck, Robustness];
      };
      prettyPrint: {
          full: (result: RdFilesResult) => string;
          query: (result: RdFilesResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: RdFilesConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": { checkedFiles: ... }; results: (...)[] };
  }

• Readonlyroxygen-arguments: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [(...)],
          ParentInformation,
          "with",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {};
          description: "Finds function parameters the roxygen documentation leaves out, and documented parameters the function does not have.";
          name: "Roxygen Arguments";
          tags: readonly [Smell, Documentation];
      };
      prettyPrint: {
          full: (result: RoxygenArgsResult) => string;
          query: (result: RoxygenArgsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
      ) => { ".meta": {}; results: (...)[] };
  }

• Readonlys3-method-consistency: {
      createSearch: () => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              checkApparentMethods: ...;
              checkMethods: ...;
              checkReplacementValues: ...;
              checkUnregistered: ...;
          };
          description: "Finds S3 methods whose formals do not match their generic, methods not registered in the NAMESPACE, and replacement functions whose last formal is not `value`.";
          name: "S3 Method Consistency";
          tags: readonly [CmdCheck, Bug, Robustness];
      };
      prettyPrint: {
          full: (r: S3MethodConsistencyResult) => string;
          query: (r: S3MethodConsistencyResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: S3MethodConsistencyConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyseeded-randomness: {
      createSearch: (
          config: SeededRandomnessConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          [(...), (...)],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: (
              ctx: ReadOnlyFlowrAnalyzerContext,
          ) => { randomnessConsumers: ...; randomnessProducers: ... };
          description: "Finds randomness-based function calls not preceded by a random seed generation function. For consistent reproducibility, functions that use randomness should only be called after a constant random seed is set using a function like `set.seed`.";
          name: "Seeded Randomness";
          tags: readonly [Smell, Robustness, Reproducibility];
      };
      prettyPrint: {
          full: (
              result: SeededRandomnessResult,
              _meta: SeededRandomnessMeta,
          ) => string;
          query: (
              result: SeededRandomnessResult,
              _meta: SeededRandomnessMeta,
          ) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: SeededRandomnessConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlysoftware-has-license: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { checkDescriptionFile: ... };
          description: "Finds software projects without a license (a LICENSE file or the License field of the DESCRIPTION).";
          name: "Software Has License";
          tags: readonly [Smell, Documentation, Usability];
      };
      prettyPrint: {
          full: (result: SoftwareHasLicenseResult) => string;
          query: (result: SoftwareHasLicenseResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: SoftwareHasLicenseConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => { ".meta": {}; results: (...)[] };
  }

• Readonlysoftware-has-tests: {
      createSearch: (
          config: SoftwareHasTestsConfig,
      ) => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { additionalTestFunctions: ... };
          description: "Finds software projects without tests (test files in a test directory or test function calls in R code).";
          name: "Software Has Tests";
          tags: readonly [Smell, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: SoftwareHasTestsResult) => string;
          query: (result: SoftwareHasTestsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: SoftwareHasTestsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => {
          ".meta": { testCallsFound: ...; testFilesFound: ... };
          results: (...)[];
      };
  }

• Readonlystop-call: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {};
          description: "Finds `stop()` calls that do not set `call.` to `FALSE`.";
          name: "Stop Without Call";
          tags: readonly [Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: LintingResult) => string;
          query: (result: LintingResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          _config: MergeableRecord,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlysyntactically-valid: {
      createSearch: () => FlowrSearchBuilder<
          "from",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          activeByDefault: false;
          certainty: BestEffort;
          defaultConfig: () => { disabledFixes: ...; preferFix: ... };
          description: "Finds syntax errors with the configured (error-tolerant) parser. Offers extensible quick fixes to repair them.";
          name: "Syntactically Valid";
          tags: readonly [Bug, Robustness, QuickFix];
      };
      prettyPrint: {
          full: (result: SyntacticallyValidResult) => string;
          query: (result: SyntacticallyValidResult) => string;
      };
      processSearchResult: (
          _elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: SyntacticallyValidConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlytrue-false-abbreviation: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          activeByDefault: false;
          certainty: Exact;
          defaultConfig: () => { reportRedefinitions: ... };
          description: "Finds `T` and `F` used for `TRUE` and `FALSE`, and top-level definitions of `T` or `F`. Off by default, as R only checks this for packages without a NAMESPACE.";
          name: "TRUE/FALSE Abbreviation";
          tags: readonly [Smell, CmdCheck, Robustness, Readability, QuickFix];
      };
      prettyPrint: {
          full: (r: TrueFalseAbbreviationResult) => string;
          query: (r: TrueFalseAbbreviationResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: TrueFalseAbbreviationConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunclosed-connection: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { closeFns: ...; openFns: ... };
          description: "Finds connections that are opened but not closed on every path opening them.";
          name: "Unclosed Connection";
          tags: readonly [Robustness, Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: LintingResult) => string;
          query: (result: LintingResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UnclosedConnectionConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyundefined-symbol: {
      createSearch: (
          _config: UndefinedSymbolConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          certainty: OverApproximative;
          defaultConfig: () => {
              checkFunctions: ...;
              checkSubscripts: ...;
              checkVariables: ...;
          };
          description: "Finds functions and variables that are neither defined locally, a base R builtin, nor exported by a loaded package.";
          name: "Undefined Symbol";
          tags: readonly [Bug, Experimental];
      };
      prettyPrint: {
          full: (result: UndefinedSymbolResult) => string;
          query: (result: UndefinedSymbolResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UndefinedSymbolConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunescaped-arguments: {
      createSearch: (
          config: UnescapedArgumentsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              acceptedInputs: ...;
              categories: ...;
              disabledCategories: ...;
              maxDecentDepth: ...;
          };
          description: "Finds arguments of critical system, evaluation, database, and HTML/JavaScript calls that are not properly escaped.";
          name: "Unescaped Arguments";
          tags: readonly [Security, Smell, Shiny, QuickFix];
      };
      prettyPrint: {
          full: (result: UnescapedArgumentsResult) => string;
          query: (result: UnescapedArgumentsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UnescapedArgumentsConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunused-definitions: {
      createSearch: (
          config: UnusedDefinitionConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          certainty: BestEffort;
          defaultConfig: () => {
              excludeExportedDefinitions: ...;
              includeFunctionDefinitions: ...;
          };
          description: "Finds definitions that are never used.";
          name: "Unused Definitions";
          tags: readonly [Readability, Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: UnusedDefinitionResult) => string;
          query: (result: UnusedDefinitionResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UnusedDefinitionConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyunused-import: {
      createSearch: () => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<(...), (...)>,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { whitelist: ... };
          description: "Finds packages that are attached but never used, so the code runs just the same without them. Requires a signature database, and packages that only do their work on load should be whitelisted in the configuration.";
          name: "Unused Import";
          tags: readonly [Smell, Readability, QuickFix];
      };
      prettyPrint: {
          full: (result: UnusedImportResult) => string;
          query: (result: UnusedImportResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          config: UnusedImportConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }

• Readonlyuseless-loop: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: () => { loopyFunctions: ... };
          description: "Finds loops that iterate only once.";
          name: "Useless Loops";
          tags: readonly [Smell, Readability];
      };
      prettyPrint: {
          full: (result: UselessLoopResult) => string;
          query: (result: UselessLoopResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<ParentInformation, (...)[]>,
          useLessLoopConfig: UselessLoopConfig,
          data: ReadonlyFlowrAnalysisProvider<KnownParser>,
      ) => Promise<{ ".meta": ...; results: ... }>;
  }