@eagleoutice/flowr 2.2.15 → 2.2.16

package/statistics/statistics.d.ts

@@ -4,6 +4,7 @@ import type { PipelineOutput } from '../core/steps/pipeline/pipeline';
 import { DEFAULT_DATAFLOW_PIPELINE } from '../core/steps/pipeline/default-pipelines';
 import type { RShell } from '../r-bridge/shell';
 import type { FeatureSelection, FeatureStatistics } from './features/feature';
+import type { FlowrConfigOptions } from '../config';
 /**
  * By default, {@link extractUsageStatistics} requires a generator, but sometimes you already know all the files
  * that you want to process. This function simply reps your requests as a generator.
@@ -14,13 +15,14 @@ type DataflowResult = PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>;
  * Extract all wanted statistic information from a set of requests using the presented R session.
  *
  * @param shell     - The R session to use
+ * @param config    - The flowr config
  * @param onRequest - A callback that is called at the beginning of each request, this may be used to debug the requests.
  * @param features  - The features to extract (see {@link allFeatureNames}).
  * @param requests  - The requests to extract the features from. May generate them on demand (e.g., by traversing a folder).
  * 										If your request is statically known, you can use {@link staticRequests} to create this generator.
  * @param rootPath  - The root path to the project, this is used to relativize the file paths in the statistics.
  */
-export declare function extractUsageStatistics<T extends RParseRequestFromText | RParseRequestFromFile>(shell: RShell, onRequest: (request: T) => void, features: FeatureSelection, requests: AsyncGenerator<T>, rootPath?: string): Promise<{
+export declare function extractUsageStatistics<T extends RParseRequestFromText | RParseRequestFromFile>(shell: RShell, config: FlowrConfigOptions, onRequest: (request: T) => void, features: FeatureSelection, requests: AsyncGenerator<T>, rootPath?: string): Promise<{
     features: FeatureStatistics;
     meta: MetaStatistics;
     outputs: Map<T, DataflowResult>;

package/statistics/statistics.js

@@ -30,13 +30,14 @@ function staticRequests(...requests) {
  * Extract all wanted statistic information from a set of requests using the presented R session.
  *
  * @param shell     - The R session to use
+ * @param config    - The flowr config
  * @param onRequest - A callback that is called at the beginning of each request, this may be used to debug the requests.
  * @param features  - The features to extract (see {@link allFeatureNames}).
  * @param requests  - The requests to extract the features from. May generate them on demand (e.g., by traversing a folder).
  * 										If your request is statically known, you can use {@link staticRequests} to create this generator.
  * @param rootPath  - The root path to the project, this is used to relativize the file paths in the statistics.
  */
-async function extractUsageStatistics(shell, onRequest, features, requests, rootPath) {
+async function extractUsageStatistics(shell, config, onRequest, features, requests, rootPath) {
     let result = initializeFeatureStatistics();
     const meta = (0, meta_statistics_1.initialMetaStatistics)();
     const outputs = new Map();
@@ -46,7 +47,7 @@ async function extractUsageStatistics(shell, onRequest, features, requests, root
         const suffix = request.request === 'file' ? request.content.replace(new RegExp('^' + (rootPath ?? '')), '') : undefined;
         try {
             let output;
-            ({ stats: result, output } = await extractSingle(result, shell, request, features, suffix));
+            ({ stats: result, output } = await extractSingle(result, shell, request, features, suffix, config));
             outputs.set(request, output);
             processMetaOnSuccessful(meta, request);
             meta.numberOfNormalizedNodes.push(output.normalize.idMap.size);
@@ -80,10 +81,10 @@ function processMetaOnSuccessful(meta, request) {
     }
 }
 const parser = new xmldom_1.DOMParser();
-async function extractSingle(result, shell, request, features, suffixFilePath) {
+async function extractSingle(result, shell, request, features, suffixFilePath, config) {
     const slicerOutput = await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
         request, parser: shell
-    }).allRemainingSteps();
+    }, config).allRemainingSteps();
     // retrieve parsed xml through (legacy) xmlparsedata
     const suffix = request.request === 'file' ? ', encoding="utf-8"' : '';
     shell.sendCommands(`try(flowr_parsed<-parse(${request.request}=${JSON.stringify(request.content)},keep.source=TRUE${suffix}),silent=FALSE)`, 'try(flowr_output<-xmlparsedata::xml_parse_data(flowr_parsed,includeText=TRUE,pretty=FALSE),silent=FALSE)');

package/util/containers.d.ts

@@ -13,7 +13,7 @@ export declare function getAccessOperands<OtherInfo>(args: readonly RFunctionArg
     accessArg: RArgument<OtherInfo & ParentInformation> | undefined;
 };
 /**
- * Resolves the passed name in the passed environment and returns the indicesCollection of the resolved definitions.
+ * Resolves the passed name within the passed environment and returns the indicesCollection of the resolved definitions.
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
@@ -25,9 +25,10 @@ export declare function resolveIndicesByName(name: Identifier, environment: REnv
  *
  * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
  *
- * @param accessedArg - The argument to resolve
- * @param accessArg - The argument which is used to filter the indices
- * @param environment - The environment in which {@link accessedArg} is resolved
+ * @param accessedArg        - The argument to resolve
+ * @param accessArg          - The argument which is used to filter the indices
+ * @param environment        - The environment in which {@link accessedArg} is resolved
+ * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
  * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
  */
 export declare function resolveSingleIndex(accessedArg: {
@@ -38,8 +39,9 @@ export declare function resolveSingleIndex(accessedArg: {
 /**
  * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
  *
- * @param indicesCollection - The {@link ContainerIndicesCollection} to filter
- * @param accessArg - The argument which is used to filter {@link indicesCollection}
+ * @param indicesCollection  - The {@link ContainerIndicesCollection} to filter
+ * @param accessArg          - The argument which is used to filter {@link indicesCollection}
+ * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
  * @returns The filtered copy of {@link indicesCollection}
  */
 export declare function filterIndices(indicesCollection: ContainerIndicesCollection, accessArg: {
@@ -54,8 +56,9 @@ export declare function filterIndices(indicesCollection: ContainerIndicesCollect
  * ```
  * would result in a list with the index `credentials`, which has the subIndex `username`.
  *
- * @param accessedArg - The top level argument that is accessed
- * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @param accessedArg         - The top level argument that is accessed
+ * @param leafIndices         - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @param constructIdentifier - A function that constructs the identifier for the index from the argument
  * @returns The constructed nested access
  */
 export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<OtherInfo & ParentInformation>, leafIndices: ContainerIndices, constructIdentifier: (arg: RArgument<OtherInfo & ParentInformation>) => IndexIdentifier): ContainerIndices[];
@@ -63,6 +66,6 @@ export declare function constructNestedAccess<OtherInfo>(accessedArg: RAccess<Ot
  * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
  *
  * @param indicesCollection - Indices where to add the sub indices.
- * @param leafSubIndices - Indices that are added to the leaf indices.
+ * @param leafSubIndices    - Indices that are added to the leaf indices.
  */
 export declare function addSubIndicesToLeafIndices(indicesCollection: ContainerIndices[], leafSubIndices: ContainerIndices[]): ContainerIndices[];

package/util/containers.js

@@ -20,7 +20,7 @@ function getAccessOperands(args) {
     return { accessedArg, accessArg };
 }
 /**
- * Resolves the passed name in the passed environment and returns the indicesCollection of the resolved definitions.
+ * Resolves the passed name within the passed environment and returns the indicesCollection of the resolved definitions.
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
@@ -35,9 +35,10 @@ function resolveIndicesByName(name, environment) {
  *
  * If no indices could be found that match the `accessArg`, the original indices are returned as overapproximation.
  *
- * @param accessedArg - The argument to resolve
- * @param accessArg - The argument which is used to filter the indices
- * @param environment - The environment in which {@link accessedArg} is resolved
+ * @param accessedArg        - The argument to resolve
+ * @param accessArg          - The argument which is used to filter the indices
+ * @param environment        - The environment in which {@link accessedArg} is resolved
+ * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
  * @returns The filtered {@link ContainerIndicesCollection} of the resolved {@link accessedArg}
  */
 function resolveSingleIndex(accessedArg, accessArg, environment, isIndexBasedAccess) {
@@ -55,8 +56,9 @@ function resolveSingleIndex(accessedArg, accessArg, environment, isIndexBasedAcc
 /**
  * Filters the single indices of the {@link indicesCollection} according to the lexeme of the {@link accessArg}.
  *
- * @param indicesCollection - The {@link ContainerIndicesCollection} to filter
- * @param accessArg - The argument which is used to filter {@link indicesCollection}
+ * @param indicesCollection  - The {@link ContainerIndicesCollection} to filter
+ * @param accessArg          - The argument which is used to filter {@link indicesCollection}
+ * @param isIndexBasedAccess - Whether the access is index-based (e.g. `x[1]`) or name-based (e.g. `x$name`)
  * @returns The filtered copy of {@link indicesCollection}
  */
 function filterIndices(indicesCollection, accessArg, isIndexBasedAccess) {
@@ -83,8 +85,9 @@ function filterIndices(indicesCollection, accessArg, isIndexBasedAccess) {
  * ```
  * would result in a list with the index `credentials`, which has the subIndex `username`.
  *
- * @param accessedArg - The top level argument that is accessed
- * @param leafIndices - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @param accessedArg         - The top level argument that is accessed
+ * @param leafIndices         - The index at the end of the nested access i.e. `c` in `a$b$c`.
+ * @param constructIdentifier - A function that constructs the identifier for the index from the argument
  * @returns The constructed nested access
  */
 function constructNestedAccess(accessedArg, leafIndices, constructIdentifier) {
@@ -116,7 +119,7 @@ function constructNestedAccess(accessedArg, leafIndices, constructIdentifier) {
  * Adds the passed list of {@link leafSubIndices} to the leaf (sub-)indices of {@link indicesCollection}.
  *
  * @param indicesCollection - Indices where to add the sub indices.
- * @param leafSubIndices - Indices that are added to the leaf indices.
+ * @param leafSubIndices    - Indices that are added to the leaf indices.
  */
 function addSubIndicesToLeafIndices(indicesCollection, leafSubIndices) {
     const result = [];

package/util/objects.d.ts

@@ -1,4 +1,4 @@
-import type { DeepPartial, DeepRequired } from 'ts-essentials';
+import type { DeepPartial, DeepReadonly, DeepRequired } from 'ts-essentials';
 /**
  * checks if `item` is an object (it may be an array, ...)
  */
@@ -6,13 +6,14 @@ export declare function isObjectOrArray(item: unknown): boolean;
 export type MergeableRecord = Record<string, unknown>;
 export type MergeableArray = unknown[];
 export type Mergeable = MergeableRecord | MergeableArray;
+type OrReadonly<T> = T | Readonly<T> | DeepReadonly<T>;
 /**
  * Given two objects deeply merges them, if an object is an array it will merge the array values!
  * Guarantees some type safety by requiring objects to merge to be from the same type (allows undefined)
  */
-export declare function deepMergeObject<T extends Mergeable>(base: Required<T>, addon?: T | DeepPartial<T> | Partial<T>): Required<T>;
-export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<T>, addon?: T | DeepPartial<T> | Partial<T>): DeepRequired<T>;
-export declare function deepMergeObject<T extends Mergeable>(base: T, addon?: DeepPartial<T> | Partial<T>): T;
+export declare function deepMergeObject<T extends Mergeable>(base: Required<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): Required<T>;
+export declare function deepMergeObject<T extends Mergeable>(base: DeepRequired<OrReadonly<T>>, addon?: T | DeepPartial<T> | Partial<T>): DeepRequired<T>;
+export declare function deepMergeObject<T extends Mergeable>(base: OrReadonly<T>, addon?: DeepPartial<T> | Partial<T>): T;
 export declare function deepMergeObject(base: Mergeable, addon: Mergeable): Mergeable;
 export declare function deepMergeObject(base?: Mergeable, addon?: Mergeable): Mergeable | undefined;
 type Defined<T> = Exclude<T, undefined>;

package/util/range.d.ts

@@ -45,7 +45,7 @@ export declare function getRangeEnd(p: SourceRange | undefined): SourcePosition
  * @param ec - end column
  */
 export declare function rangeFrom(sl: number | string, sc: number | string, el: number | string, ec: number | string): SourceRange;
-export declare function mergeRanges(...rs: SourceRange[]): SourceRange;
+export declare function mergeRanges(...rs: (SourceRange | undefined)[]): SourceRange;
 /**
  * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
  */
@@ -64,3 +64,7 @@ export declare function addRanges([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl,
  * @returns a positive number if `r1` comes after `r2`, a negative number if `r1` comes before `r2`, and `0` if they are equal
  */
 export declare function rangeCompare([r1sl, r1sc, ,]: SourceRange, [r2sl, r2sc, ,]: SourceRange): number;
+/**
+ * Checks if the first range is a subset of the second range.
+ */
+export declare function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec]: SourceRange, [r2sl, r2sc, r2el, r2ec]: SourceRange): boolean;

package/util/range.js

@@ -8,6 +8,7 @@ exports.rangeStartsCompletelyBefore = rangeStartsCompletelyBefore;
 exports.rangesOverlap = rangesOverlap;
 exports.addRanges = addRanges;
 exports.rangeCompare = rangeCompare;
+exports.rangeIsSubsetOf = rangeIsSubsetOf;
 const assert_1 = require("./assert");
 function getRangeStart(p) {
     return p === undefined ? undefined : [p[0], p[1]];
@@ -27,11 +28,12 @@ function rangeFrom(sl, sc, el, ec) {
     return [Number(sl), Number(sc), Number(el), Number(ec)];
 }
 function mergeRanges(...rs) {
-    (0, assert_1.guard)(rs.length > 0, 'Cannot merge no ranges');
-    return rs.reduce(([sl, sc, el, ec], [nsl, nsc, nel, nec]) => [
+    const rsSafe = rs.filter(assert_1.isNotUndefined);
+    (0, assert_1.guard)(rsSafe.length > 0, 'Cannot merge no ranges');
+    return rsSafe.reduce(([sl, sc, el, ec], [nsl, nsc, nel, nec]) => [
         ...(sl < nsl || (sl === nsl && sc < nsc) ? [sl, sc] : [nsl, nsc]),
         ...(el > nel || (el === nel && ec > nec) ? [el, ec] : [nel, nec])
-    ], rs[0]);
+    ], rsSafe[0]);
 }
 /**
  * @returns true iff `r1` starts and ends before `r2` starts (i.e., if `r1` and `r2` do not overlap and `r1` comes before `r2`
@@ -64,4 +66,10 @@ function rangeCompare([r1sl, r1sc, ,], [r2sl, r2sc, ,]) {
         return r1sl - r2sl;
     }
 }
+/**
+ * Checks if the first range is a subset of the second range.
+ */
+function rangeIsSubsetOf([r1sl, r1sc, r1el, r1ec], [r2sl, r2sc, r2el, r2ec]) {
+    return r1sl >= r2sl && r1sc >= r2sc && r1el <= r2el && r1ec <= r2ec;
+}
 //# sourceMappingURL=range.js.map

package/util/text/strings.d.ts

@@ -19,3 +19,9 @@ export declare function joinWithLast(strs: readonly string[], { join, last, join
     last?: string;
     joinTwo?: string;
 }): string;
+/**
+ * Check if the given path is an absolute path.
+ */
+export declare function isAbsolutePath(p: string, regex: RegExp | undefined): boolean;
+/** collect '-' at the start until '[' or '(' is reached, then drop the same from the end if present otherwise return the value as is */
+export declare function dropRawStringSurround(value: string): string;

package/util/text/strings.js

@@ -1,9 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startAndEndsWith = startAndEndsWith;
 exports.withoutWhitespace = withoutWhitespace;
 exports.longestCommonPrefix = longestCommonPrefix;
 exports.joinWithLast = joinWithLast;
+exports.isAbsolutePath = isAbsolutePath;
+exports.dropRawStringSurround = dropRawStringSurround;
+const path_1 = __importDefault(require("path"));
 /**
  * Check if the given string starts and ends with the given letter
  */
@@ -51,4 +57,33 @@ function joinWithLast(strs, { join = ', ', last = ', and ', joinTwo = ' and ' }
     }
     return strs.slice(0, -1).join(join) + last + strs[strs.length - 1];
 }
+/**
+ * Check if the given path is an absolute path.
+ */
+function isAbsolutePath(p, regex) {
+    return regex?.test(p) || p.startsWith('/') || p.startsWith('\\') ||
+        /[a-zA-Z]:[\\/]/.test(p) || // Windows absolute path
+        path_1.default.normalize(p + '/') === path_1.default.normalize(path_1.default.resolve(p) + '/');
+}
+const CorrespondingClose = {
+    '(': ')',
+    '[': ']',
+    '{': '}'
+};
+/** collect '-' at the start until '[' or '(' is reached, then drop the same from the end if present otherwise return the value as is */
+function dropRawStringSurround(value) {
+    const dashCount = value.match(/^-*/)?.[0].length ?? 0;
+    const open = value[dashCount];
+    if (open === '[' || open === '(' || open === '{') {
+        // if the value starts with a dash and then a bracket, we drop the dashes at the end
+        const end = value.endsWith(CorrespondingClose[open] + '-'.repeat(dashCount)) ? dashCount : undefined;
+        if (end !== undefined) {
+            return value.slice(dashCount + 1, -end - 1);
+        }
+        else {
+            return value;
+        }
+    }
+    return value;
+}
 //# sourceMappingURL=strings.js.map

package/util/version.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
 const semver_1 = require("semver");
 // this is automatically replaced with the current version by release-it
-const version = '2.2.15';
+const version = '2.2.16';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }

package/linter/rules/1-deprecated-functions.d.ts

@@ -1,34 +0,0 @@
-import type { LintingResult } from '../linter-format';
-import { LintingCertainty } from '../linter-format';
-import type { MergeableRecord } from '../../util/objects';
-import type { SourceRange } from '../../util/range';
-import type { Identifier } from '../../dataflow/environments/identifier';
-export interface DeprecatedFunctionsResult extends LintingResult {
-    function: string;
-    range: SourceRange;
-}
-export interface DeprecatedFunctionsConfig extends MergeableRecord {
-    /**
-     * The list of function names that should be marked as deprecated.
-     */
-    deprecatedFunctions: string[];
-}
-export interface DeprecatedFunctionsMetadata extends MergeableRecord {
-    totalRelevant: number;
-    totalNotDeprecated: number;
-}
-export declare const R1_DEPRECATED_FUNCTIONS: {
-    readonly createSearch: (_config: DeprecatedFunctionsConfig) => import("../../search/flowr-search-builder").FlowrSearchBuilder<"all", ["with"], import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/search-executor/search-enrichers").EnrichedFlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>>;
-    readonly processSearchResult: (elements: import("../../search/flowr-search").FlowrSearchElements<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../search/flowr-search").FlowrSearchElement<import("../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>[]>, config: DeprecatedFunctionsConfig) => {
-        results: {
-            certainty: LintingCertainty.Definitely;
-            function: Identifier;
-            range: SourceRange;
-        }[];
-        '.meta': DeprecatedFunctionsMetadata;
-    };
-    readonly prettyPrint: (result: DeprecatedFunctionsResult) => string;
-    readonly defaultConfig: {
-        readonly deprecatedFunctions: ["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"];
-    };
-};

package/linter/rules/1-deprecated-functions.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.R1_DEPRECATED_FUNCTIONS = void 0;
-const linter_format_1 = require("../linter-format");
-const flowr_search_builder_1 = require("../../search/flowr-search-builder");
-const dfg_1 = require("../../util/mermaid/dfg");
-const search_enrichers_1 = require("../../search/search-executor/search-enrichers");
-exports.R1_DEPRECATED_FUNCTIONS = {
-    createSearch: (_config) => flowr_search_builder_1.Q.all().with(search_enrichers_1.Enrichment.CallTargets),
-    processSearchResult: (elements, config) => {
-        const metadata = {
-            totalRelevant: 0,
-            totalNotDeprecated: 0
-        };
-        return {
-            results: elements.getElements()
-                .flatMap(element => {
-                const targets = (0, search_enrichers_1.enrichmentContent)(element, search_enrichers_1.Enrichment.CallTargets).targets;
-                // if there is a call target that is not built-in (ie a custom function), we don't want to mark it as deprecated
-                // eventually we'd want to solve this with an argument to the CallTargets enrichment like satisfiesCallTargets does!
-                if (targets.some(t => typeof t !== 'string')) {
-                    return [];
-                }
-                return targets.map(target => {
-                    metadata.totalRelevant++;
-                    return {
-                        range: element.node.info.fullRange,
-                        target: target
-                    };
-                });
-            })
-                .filter(element => {
-                if (config.deprecatedFunctions.includes(element.target)) {
-                    return true;
-                }
-                else {
-                    metadata.totalNotDeprecated++;
-                    return false;
-                }
-            })
-                .map(element => ({
-                certainty: linter_format_1.LintingCertainty.Definitely,
-                function: element.target,
-                range: element.range
-            })),
-            '.meta': metadata
-        };
-    },
-    prettyPrint: result => `Function \`${result.function}\` at ${(0, dfg_1.formatRange)(result.range)}`,
-    defaultConfig: {
-        deprecatedFunctions: ['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',]
-    }
-};
-//# sourceMappingURL=1-deprecated-functions.js.map