Variable LintingRulesConst

Type Declaration

• Readonlyabsolute-file-paths: {
      createSearch: (
          config: AbsoluteFilePathConfig,
      ) => FlowrSearchBuilderOut<"from-query", [], ParentInformation, "unique">;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              absolutePathRegex: undefined;
              additionalPathFunctions: readonly [];
              include: { allStrings: false; constructed: true };
              useAsWd: "@script";
          };
          description: "Checks whether file paths are absolute.";
          name: "Absolute Paths";
          tags: readonly [Robustness, Reproducibility, Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: AbsoluteFilePathResult) => string;
          query: (result: AbsoluteFilePathResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: AbsoluteFilePathConfig,
          data: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": AbsoluteFilePathMetadata;
          results: AbsoluteFilePathResult[];
      };
  }

• Readonlydataframe-access-validation: {
      createSearch: () => FlowrSearchBuilder<
          "all",
          [],
          ParentInformation,
          FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { readLoadedData: false };
          description: "Validates the existence of accessed columns and rows of dataframes.";
          name: "Dataframe Access Validation";
          tags: readonly [Bug, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: DataFrameAccessValidationResult) => string;
          query: (result: DataFrameAccessValidationResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: DataFrameAccessValidationConfig,
          data: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => Promise<
          {
              ".meta": DataFrameAccessValidationMetadata;
              results: DataFrameAccessValidationResult[];
          },
      >;
  }

• Readonlydead-code: {
      createSearch: (
          config: DeadCodeConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "with">;
      info: {
          certainty: BestEffort;
          defaultConfig: {};
          description: "Marks areas of code that are never reached during execution.";
          name: "Dead Code";
          tags: readonly [Smell, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: DeadCodeResult) => string;
          query: (result: DeadCodeResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          _config: DeadCodeConfig,
          _data: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => { ".meta": DeadCodeMetadata; results: DeadCodeResult[] };
  }

• Readonlydeprecated-functions: {
      createSearch: (
          config: FunctionsToDetectConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          ["filter", "with"],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              fns: readonly [
                  "all_equal",
                  "arrange_all",
                  "distinct_all",
                  "filter_all",
                  "group_by_all",
                  "summarise_all",
                  "mutate_all",
                  "select_all",
                  "vars",
                  "all_vars",
                  "id",
                  "failwith",
                  "select_vars",
                  "rename_vars",
                  "select_var",
                  "current_vars",
                  "bench_tbls",
                  "compare_tbls",
                  "compare_tbls2",
                  "eval_tbls",
                  "eval_tbls2",
                  "location",
                  "changes",
                  "combine",
                  "do",
                  "funs",
                  "add_count_",
                  "add_tally_",
                  "arrange_",
                  "count_",
                  "distinct_",
                  "do_",
                  "filter_",
                  "funs_",
                  "group_by_",
                  "group_indices_",
                  "mutate_",
                  "tally_",
                  "transmute_",
                  "rename_",
                  "rename_vars_",
                  "select_",
                  "select_vars_",
                  "slice_",
                  "summarise_",
                  "summarize_",
                  "summarise_each",
                  "src_local",
                  "tbl_df",
                  "add_rownames",
                  "group_nest",
                  "group_split",
                  "with_groups",
                  "nest_by",
                  "progress_estimated",
                  "recode",
                  "sample_n",
                  "top_n",
                  "transmute",
                  "fct_explicit_na",
                  "aes_",
                  "aes_auto",
                  "annotation_logticks",
                  "is.Coord",
                  "coord_flip",
                  "coord_map",
                  "is.facet",
                  "fortify",
                  "is.ggproto",
                  "guide_train",
                  "is.ggplot",
                  "qplot",
                  "is.theme",
                  "gg_dep",
                  "liply",
                  "isplit2",
                  "list_along",
                  "cross",
                  "invoke",
                  "at_depth",
                  "prepend",
                  "rerun",
                  "splice",
                  "`%@%`",
                  "rbernoulli",
                  "rdunif",
                  "when",
                  "update_list",
                  "map_raw",
                  "accumulate",
                  "reduce_right",
                  "flatten",
                  "map_dfr",
                  "as_vector",
                  "transpose",
                  "melt_delim",
                  "melt_fwf",
                  "melt_table",
                  "read_table2",
                  "str_interp",
                  "as_tibble",
                  "data_frame",
                  "tibble_",
                  "data_frame_",
                  "lst_",
                  "as_data_frame",
                  "as.tibble",
                  "frame_data",
                  "trunc_mat",
                  "is.tibble",
                  "tidy_names",
                  "set_tidy_names",
                  "repair_names",
                  "extract_numeric",
                  "complete_",
                  "drop_na_",
                  "expand_",
                  "crossing_",
                  "nesting_",
                  "extract_",
                  "fill_",
                  "gather_",
                  "nest_",
                  "separate_rows_",
                  "separate_",
                  "spread_",
                  "unite_",
                  "unnest_",
                  "extract",
                  "gather",
                  "nest_legacy",
                  "separate_rows",
                  "separate",
                  "spread",
              ];
          };
          description: "Marks deprecated functions that should not be used anymore.";
          name: "Deprecated Functions";
          tags: readonly [Deprecated, Smell, Usability, Reproducibility];
      };
      prettyPrint: {
          full: (result: FunctionsResult) => string;
          query: (result: FunctionsResult) => string;
      };
      processSearchResult: <T extends FlowrSearchElement<ParentInformation>[]>(
          elements: FlowrSearchElements<ParentInformation, T>,
          _config: unknown,
          _data: unknown,
          refineSearch?: (
              elements: T,
          ) => (T[number] & { certainty?: LintingResultCertainty })[],
      ) => { ".meta": FunctionsMetadata; results: FunctionsResult[] };
  }

• Readonlyfile-path-validity: {
      createSearch: (
          config: FilePathValidityConfig,
      ) => FlowrSearchBuilderOut<"from-query", [], ParentInformation, "with">;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              additionalReadFunctions: readonly [];
              additionalWriteFunctions: readonly [];
              includeUnknown: false;
          };
          description: "Checks whether file paths used in read and write operations are valid and point to existing files.";
          name: "File Path Validity";
          tags: readonly [Robustness, Reproducibility, Bug];
      };
      prettyPrint: {
          full: (result: FilePathValidityResult) => string;
          query: (result: FilePathValidityResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: FilePathValidityConfig,
          data: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": FilePathValidityMetadata;
          results: FilePathValidityResult[];
      };
  }

• Readonlynaming-convention: {
      createSearch: (
          _config: NamingConventionConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          certainty: OverApproximative;
          defaultConfig: { caseing: "auto"; ignoreNonAlpha: true };
          description: "Checks whether the symbols conform to a certain naming convention";
          name: "Naming Convention";
          tags: readonly [Style, QuickFix];
      };
      prettyPrint: {
          full: (result: NamingConventionResult) => string;
          query: (result: NamingConventionResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: NamingConventionConfig,
          data: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": { numBreak: number; numMatches: number };
          results: NamingConventionResult[];
      };
  }

• Readonlynetwork-functions: {
      createSearch: (
          config: NetworkFunctionsConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          ["filter", "with"],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              fns: readonly [
                  "read.table",
                  "read.csv",
                  "read.csv2",
                  "read.delim",
                  "read.delim2",
                  "readRDS",
                  "download.file",
                  "url",
                  "GET",
                  "POST",
                  "PUT",
                  "DELETE",
                  "PATCH",
                  "HEAD",
                  "content",
                  "handle",
                  "get_callback",
                  "VERB",
                  "fread",
                  "gzcon",
                  "readlines",
                  "source",
                  "load",
                  "curl_download",
                  "curl_fetch_memory",
                  "getURL",
                  "getForm",
                  "read_html",
                  "html_nodes",
                  "html_text",
                  "fromJSON",
                  "read.xlsx",
                  "drive_download",
                  "drive_get",
                  "s3read_using",
                  "s3write_using",
                  "storage_download",
                  "AnnotationHub",
                  "ExperimentHub",
              ];
              onlyTriggerWithArgument: RegExp;
          };
          description: "Marks network 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,
              FlowrSearchElement<ParentInformation>[],
          >,
          c: NetworkFunctionsConfig,
          d: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => { ".meta": FunctionsMetadata; results: FunctionsResult[] };
  }

• Readonlyproblematic-eval: {
      createSearch: (
          config: ProblematicEvalConfig,
      ) => FlowrSearchBuilder<
          "from-query",
          [],
          ParentInformation,
          FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { considerAsEval: "^eval$" };
          description: "Detects uses of eval-like functions whose inputs are not statically constant. Prints the computed input-sources for the eval and flags usages that depend on non-constant/trusted inputs.";
          name: "Problematic eval";
          tags: readonly [Security, Smell, Readability, Performance];
      };
      prettyPrint: {
          full: (result: ProblematicEvalResult) => string;
          query: (result: ProblematicEvalResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          _config: ProblematicEvalConfig,
          data: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => Promise<
          { ".meta": ProblematicEvalMetadata; results: ProblematicEvalResult[] },
      >;
  }

• Readonlyroxygen-arguments: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {};
          description: "Checks whether a function has undocumented or overdocumented parameters";
          name: "Roxygen Arguments";
          tags: readonly [Smell, Documentation, Style];
      };
      prettyPrint: {
          full: (result: RoxygenArgsResult) => string;
          query: (result: RoxygenArgsResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          _config: MergeableRecord,
          __namedParameters: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => { ".meta": {}; results: Writable<RoxygenArgsResult>[] };
  }

• Readonlyseeded-randomness: {
      createSearch: (
          config: SeededRandomnessConfig,
      ) => FlowrSearchBuilderOut<
          "all",
          ["filter", "with", "filter"],
          ParentInformation,
          "with",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {
              randomnessConsumers: readonly [
                  "jitter",
                  "sample",
                  "sample.int",
                  "arima.sim",
                  "kmeans",
                  "princomp",
                  "rcauchy",
                  "rchisq",
                  "rexp",
                  "rgamma",
                  "rgeom",
                  "rlnorm",
                  "rlogis",
                  "rmultinom",
                  "rnbinom",
                  "rnorm",
                  "rpois",
                  "runif",
                  "pointLabel",
                  "some",
                  "rbernoulli",
                  "rdunif",
                  "generateSeedVectors",
              ];
              randomnessProducers: readonly [
                  { name: "set.seed"; type: "function" },
                  { name: ".Random.seed"; type: "assignment" },
              ];
          };
          description: "Checks whether randomness-based function calls are 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 [Robustness, Reproducibility];
      };
      prettyPrint: {
          full: (
              result: SeededRandomnessResult,
              _meta: SeededRandomnessMeta,
          ) => string;
          query: (
              result: SeededRandomnessResult,
              _meta: SeededRandomnessMeta,
          ) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: SeededRandomnessConfig,
          __namedParameters: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": SeededRandomnessMeta;
          results: {
              certainty: LintingResultCertainty;
              function: BrandedIdentifier;
              involvedId: NodeId;
              loc: [
                  startLine: number,
                  startColumn: number,
                  endLine: number,
                  endColumn: number,
                  f?: string,
              ];
          }[];
      };
  }

• Readonlystop-call: {
      createSearch: () => FlowrSearchBuilderOut<
          "get",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: {};
          description: "Checks whether stop calls without call. argument set to FALSE are used.";
          name: "Stop without call.=False argument";
          tags: readonly [Smell];
      };
      prettyPrint: {
          full: (result: StopWithCallResult) => string;
          query: (result: StopWithCallResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          _config: MergeableRecord,
          __namedParameters: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": StopWithCallMetadata;
          results: Writable<StopWithCallResult>[];
      };
  }

• Readonlyunused-definitions: {
      createSearch: (
          config: UnusedDefinitionConfig,
      ) => FlowrSearchBuilderOut<"all", [], ParentInformation, "filter">;
      info: {
          certainty: BestEffort;
          defaultConfig: { includeFunctionDefinitions: true };
          description: "Checks for unused definitions.";
          name: "Unused Definitions";
          tags: readonly [Readability, Smell, QuickFix];
      };
      prettyPrint: {
          full: (result: UnusedDefinitionResult) => string;
          query: (result: UnusedDefinitionResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          config: UnusedDefinitionConfig,
          data: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": UnusedDefinitionMetadata;
          results: UnusedDefinitionResult[];
      };
  }

• Readonlyuseless-loop: {
      createSearch: () => FlowrSearchBuilderOut<
          "all",
          [],
          ParentInformation,
          "filter",
      >;
      info: {
          certainty: BestEffort;
          defaultConfig: { loopyFunctions: Set<BuiltInProcName> };
          description: "Detect loops which only iterate once";
          name: "Useless Loops";
          tags: readonly [Smell, Readability];
      };
      prettyPrint: {
          full: (result: UselessLoopResult) => string;
          query: (result: UselessLoopResult) => string;
      };
      processSearchResult: (
          elements: FlowrSearchElements<
              ParentInformation,
              FlowrSearchElement<ParentInformation>[],
          >,
          useLessLoopConfig: UselessLoopConfig,
          __namedParameters: {
              analyzer: ReadonlyFlowrAnalysisProvider;
              cfg: ControlFlowInformation;
              dataflow: DataflowInformation;
              normalize: NormalizedAst;
          },
      ) => {
          ".meta": { numOfUselessLoops: number };
          results: {
              certainty: Certain;
              involvedId: NodeId;
              loc: [
                  startLine: number,
                  startColumn: number,
                  endLine: number,
                  endColumn: number,
                  f?: string,
              ];
              name: string;
          }[];
      };
  }