@eagleoutice/flowr 2.6.1 → 2.6.3

package/search/search-executor/search-mappers.d.ts

@@ -1,19 +1,22 @@
 import type { FlowrSearchElement } from '../flowr-search';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { Enrichment } from './search-enrichers';
+import { type Enrichment } from './search-enrichers';
 import type { MergeableRecord } from '../../util/objects';
-import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
+import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 export declare enum Mapper {
     Enrichment = "enrichment"
 }
 export interface MapperData<Arguments extends string | MergeableRecord> {
-    mapper: (e: FlowrSearchElement<ParentInformation>, data: FlowrAnalysisProvider, args: Arguments) => FlowrSearchElement<ParentInformation>[];
+    mapper: (e: FlowrSearchElement<ParentInformation>, data: ReadonlyFlowrAnalysisProvider, args: Arguments) => FlowrSearchElement<ParentInformation>[];
 }
 export type MapperArguments<M extends Mapper> = typeof Mappers[M] extends MapperData<infer Arguments> ? Arguments : never;
 declare const Mappers: {
     readonly enrichment: {
-        mapper: (e: FlowrSearchElement<ParentInformation>, _data: FlowrAnalysisProvider, enrichment: Enrichment) => FlowrSearchElement<ParentInformation>[];
+        mapper: (e: FlowrSearchElement<ParentInformation>, _data: ReadonlyFlowrAnalysisProvider, enrichment: Enrichment) => FlowrSearchElement<ParentInformation>[];
     };
 };
-export declare function map<Element extends FlowrSearchElement<ParentInformation>, MapperType extends Mapper>(e: Element, data: FlowrAnalysisProvider, mapper: MapperType, args: MapperArguments<MapperType>): Element[];
+/**
+ * Maps the given search element using the specified mapper and arguments.
+ */
+export declare function map<Element extends FlowrSearchElement<ParentInformation>, MapperType extends Mapper>(e: Element, data: ReadonlyFlowrAnalysisProvider, mapper: MapperType, args: MapperArguments<MapperType>): Element[];
 export {};

package/search/search-executor/search-mappers.js

@@ -16,6 +16,9 @@ const Mappers = {
         }
     }
 };
+/**
+ * Maps the given search element using the specified mapper and arguments.
+ */
 function map(e, data, mapper, args) {
     return Mappers[mapper].mapper(e, data, args);
 }

package/search/search-executor/search-transformer.d.ts

@@ -1,11 +1,11 @@
 import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchTransformerNodeBase } from '../flowr-search';
 import type { LastOfArray, Tail2TypesOrUndefined, TailOfArray } from '../../util/collections/arrays';
-import type { FlowrFilterExpression } from '../flowr-search-filters';
+import { type FlowrFilterExpression } from '../flowr-search-filters';
 import type { FlowrSearchGeneratorNode } from './search-generators';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { Enrichment, EnrichmentElementArguments } from './search-enrichers';
-import type { Mapper, MapperArguments } from './search-mappers';
-import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
+import { type Enrichment, type EnrichmentElementArguments } from './search-enrichers';
+import { type Mapper, type MapperArguments } from './search-mappers';
+import type { ReadonlyFlowrAnalysisProvider } from '../../project/flowr-analyzer';
 /**
  * This is a union of all possible transformer node types
  */
@@ -34,38 +34,41 @@ export declare const transformers: {
     readonly with: typeof getWith;
     readonly map: typeof getMap;
 };
+/**
+ * Gets a search-api transformer function for the given name.
+ */
 export declare function getTransformer<Name extends TransformerNames>(name: Name): typeof transformers[Name];
 /** If we already have no more elements, cascade will not add any but keep the empty elements, otherwise it will now be NewElements */
 type CascadeEmpty<Elements extends FlowrSearchElement<ParentInformation>[], NewElements extends FlowrSearchElement<ParentInformation>[]> = Elements extends [] ? FlowrSearchElements<ParentInformation, []> : FlowrSearchElements<ParentInformation, NewElements>;
-declare function getFirst<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, [Elements[0]]>;
-declare function getLast<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, [LastOfArray<Elements>]>;
-declare function getIndex<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { index }: {
+declare function getFirst<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, [Elements[0]]>;
+declare function getLast<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, [LastOfArray<Elements>]>;
+declare function getIndex<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE, { index }: {
     index: number;
 }): CascadeEmpty<Elements, [Elements[number]]>;
-declare function getSelect<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { select }: {
+declare function getSelect<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE, { select }: {
     select: number[];
 }): CascadeEmpty<Elements, Elements>;
-declare function getTail<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, TailOfArray<Elements>>;
-declare function getTake<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { count }: {
+declare function getTail<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getTake<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE, { count }: {
     count: number;
 }): CascadeEmpty<Elements, TailOfArray<Elements>>;
-declare function getSkip<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { count }: {
+declare function getSkip<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE, { count }: {
     count: number;
 }): CascadeEmpty<Elements, TailOfArray<Elements>>;
-declare function getFilter<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { filter }: {
+declare function getFilter<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE, { filter }: {
     filter: FlowrFilterExpression;
 }): Promise<CascadeEmpty<Elements, Elements | []>>;
-declare function getWith<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(input: FlowrAnalysisProvider, elements: FSE, { info, args }: {
+declare function getWith<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(input: ReadonlyFlowrAnalysisProvider, elements: FSE, { info, args }: {
     info: Enrichment;
     args?: EnrichmentElementArguments<Enrichment>;
 }): Promise<FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
-declare function getMap<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { mapper, args }: {
+declare function getMap<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE, { mapper, args }: {
     mapper: Mapper;
     args: MapperArguments<Mapper>;
 }): FlowrSearchElements<ParentInformation, Elements>;
-declare function getMerge<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, other: {
+declare function getMerge<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE, other: {
     search: unknown[];
     generator: FlowrSearchGeneratorNode;
 }): Promise<FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
-declare function getUnique<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, Elements>;
+declare function getUnique<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: ReadonlyFlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, Elements>;
 export {};

package/search/search-executor/search-transformer.js

@@ -24,6 +24,9 @@ exports.transformers = {
     with: getWith,
     map: getMap
 };
+/**
+ * Gets a search-api transformer function for the given name.
+ */
 function getTransformer(name) {
     if (!exports.transformers[name]) {
         throw new Error(`Unknown transformer: ${name}`);

package/slicing/criterion/collect-all.d.ts

@@ -5,28 +5,29 @@
  */
 import type { MergeableRecord } from '../../util/objects';
 import type { SlicingCriteria } from './parse';
-import type { RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { ParentInformation, RNodeWithParent } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { RProject } from '../../r-bridge/lang-4.x/ast/model/nodes/r-project';
 /**
  * Defines the filter for collecting all possible slicing criteria.
  * @see DefaultAllVariablesFilter
  */
 export interface SlicingCriteriaFilter extends MergeableRecord {
     /**
-   * Inclusive minimum size of the slicing criteria (number of included slice points).
-   * Should be at least `1` to make sense (and of course at most {@link SlicingCriteriaFilter#maximumSize|maximum size}).
-   */
+     * Inclusive minimum size of the slicing criteria (number of included slice points).
+     * Should be at least `1` to make sense (and of course at most {@link SlicingCriteriaFilter#maximumSize|maximum size}).
+     */
     minimumSize: number;
     /**
-   * Inclusive maximum size of the slicing criteria (number of included slice points).
-   * Should be at least `1` to make sense (and of course at least {@link SlicingCriteriaFilter#minimumSize|minimum size}).
-   * <p>
-   * Be really careful with this one, as the number of possible slicing criteria can grow exponentially with the maximum size.
-   */
+     * Inclusive maximum size of the slicing criteria (number of included slice points).
+     * Should be at least `1` to make sense (and of course at least {@link SlicingCriteriaFilter#minimumSize|minimum size}).
+     * <p>
+     * Be really careful with this one, as the number of possible slicing criteria can grow exponentially with the maximum size.
+     */
     maximumSize: number;
     /**
-   * Function that determines the ids of all nodes that can be used as slicing criteria.
-   */
+     * Function that determines the ids of all nodes that can be used as slicing criteria.
+     */
     collectAll: (root: RNodeWithParent) => NodeId[];
 }
 /**
@@ -34,4 +35,4 @@ export interface SlicingCriteriaFilter extends MergeableRecord {
  * The slicing criteria will be *ordered* (i.e., it will not return `[1:2,3:4]` and `[3:4,1:2]` if `maximumSize` \> 1).
  * If there are not enough matching nodes within the ast, this will return *no* slicing criteria!
  */
-export declare function collectAllSlicingCriteria<OtherInfo>(ast: RNodeWithParent<OtherInfo>, filter: Readonly<SlicingCriteriaFilter>): Generator<SlicingCriteria, void, void>;
+export declare function collectAllSlicingCriteria<OtherInfo>(ast: RProject<OtherInfo & ParentInformation>, filter: Readonly<SlicingCriteriaFilter>): Generator<SlicingCriteria, void, void>;

package/slicing/criterion/collect-all.js

@@ -12,7 +12,7 @@ const r_function_call_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-fun
 function* collectAllSlicingCriteria(ast, filter) {
     (0, assert_1.guard)(filter.minimumSize >= 1, `Minimum size must be at least 1, but was ${filter.minimumSize}`);
     (0, assert_1.guard)(filter.maximumSize >= filter.minimumSize, `Maximum size must be at least minimum size, but was ${filter.maximumSize} < ${filter.minimumSize}`);
-    const potentialSlicingNodes = filter.collectAll(ast);
+    const potentialSlicingNodes = ast.files.flatMap(f => filter.collectAll(f.root));
     if (potentialSlicingNodes.length < filter.minimumSize) {
         return;
     }

package/slicing/criterion/parse.d.ts

@@ -11,13 +11,11 @@ export declare class CriteriaParseError extends Error {
 }
 /**
  * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
- *
  * @see {@link tryResolveSliceCriterionToId} for a version that does not throw an error
  */
 export declare function slicingCriterionToId(criterion: SingleSlicingCriterion, idMap: AstIdMap): NodeId;
 /**
  * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
- *
  * @see {@link slicingCriterionToId} for the version that throws an error
  */
 export declare function tryResolveSliceCriterionToId(criterion: string | NodeId, idMap: AstIdMap): NodeId | undefined;
@@ -26,4 +24,8 @@ export interface DecodedCriterion {
     id: NodeId;
 }
 export type DecodedCriteria = ReadonlyArray<DecodedCriterion>;
+/**
+ * Converts all slicing criteria to their corresponding node ids
+ * @throws CriteriaParseError if any of the criteria can not be resolved
+ */
 export declare function convertAllSlicingCriteriaToIds(criteria: SlicingCriteria, decorated: AstIdMap): DecodedCriteria;

package/slicing/criterion/parse.js

@@ -20,7 +20,6 @@ class CriteriaParseError extends Error {
 exports.CriteriaParseError = CriteriaParseError;
 /**
  * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
- *
  * @see {@link tryResolveSliceCriterionToId} for a version that does not throw an error
  */
 function slicingCriterionToId(criterion, idMap) {
@@ -28,14 +27,14 @@ function slicingCriterionToId(criterion, idMap) {
     if (criterion.startsWith('$')) {
         resolved = (0, node_id_1.normalizeIdToNumberIfPossible)(criterion.substring(1));
     }
-    else if (criterion.includes(':')) {
-        const [line, column] = criterion.split(':').map(c => parseInt(c));
-        resolved = locationToId([line, column], idMap);
-    }
     else if (criterion.includes('@')) {
         const [line, name] = criterion.split(/@(.*)/s); // only split at first occurrence
         resolved = conventionalCriteriaToId(parseInt(line), name, idMap);
     }
+    else if (criterion.includes(':')) {
+        const [line, column] = criterion.split(':').map(c => parseInt(c));
+        resolved = locationToId([line, column], idMap);
+    }
     if (resolved === undefined) {
         throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);
     }
@@ -43,7 +42,6 @@ function slicingCriterionToId(criterion, idMap) {
 }
 /**
  * Tries to resolve a slicing criterion to an id, but does not throw an error if it fails.
- *
  * @see {@link slicingCriterionToId} for the version that throws an error
  */
 function tryResolveSliceCriterionToId(criterion, idMap) {
@@ -96,6 +94,10 @@ function conventionalCriteriaToId(line, name, dataflowIdMap) {
     }
     return id;
 }
+/**
+ * Converts all slicing criteria to their corresponding node ids
+ * @throws CriteriaParseError if any of the criteria can not be resolved
+ */
 function convertAllSlicingCriteriaToIds(criteria, decorated) {
     return criteria.map(l => ({ criterion: l, id: slicingCriterionToId(l, decorated) }));
 }

package/slicing/static/fingerprint.d.ts

@@ -1,5 +1,13 @@
-import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import { type REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export type Fingerprint = string;
+/**
+ * Calculate a fingerprint for the given R environment information
+ * @see {@link fingerprint}
+ */
 export declare function envFingerprint(env: REnvironmentInformation): Fingerprint;
+/**
+ * Calculate a fingerprint for the given node id and environment fingerprint
+ * @see {@link envFingerprint}
+ */
 export declare function fingerprint(id: NodeId, envFingerprint: Fingerprint, onlyForSideEffects: boolean): Fingerprint;

package/slicing/static/fingerprint.js

@@ -7,6 +7,10 @@ exports.envFingerprint = envFingerprint;
 exports.fingerprint = fingerprint;
 const object_hash_1 = __importDefault(require("object-hash"));
 const environment_1 = require("../../dataflow/environments/environment");
+/**
+ * Calculate a fingerprint for the given R environment information
+ * @see {@link fingerprint}
+ */
 function envFingerprint(env) {
     return (0, object_hash_1.default)(env, {
         algorithm: 'md5',
@@ -17,6 +21,10 @@ function envFingerprint(env) {
         replacer: (v) => (0, environment_1.isDefaultBuiltInEnvironment)(v) ? undefined : v
     });
 }
+/**
+ * Calculate a fingerprint for the given node id and environment fingerprint
+ * @see {@link envFingerprint}
+ */
 function fingerprint(id, envFingerprint, onlyForSideEffects) {
     return `${id}-${envFingerprint}-${onlyForSideEffects ? '0' : '1'}`;
 }

package/slicing/static/slice-call.d.ts

@@ -1,9 +1,9 @@
 import type { NodeToSlice } from './slicer-types';
 import type { VisitingQueue } from './visiting-queue';
-import type { Fingerprint } from './fingerprint';
+import { type Fingerprint } from './fingerprint';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexInfo } from '../../dataflow/graph/vertex';
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
-import type { DataflowGraph, OutgoingEdges } from '../../dataflow/graph/graph';
+import { type DataflowGraph, type OutgoingEdges } from '../../dataflow/graph/graph';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { DataflowInformation } from '../../dataflow/info';
 /**

package/slicing/static/static-slicer.d.ts

@@ -1,9 +1,9 @@
 import type { SliceResult } from './slicer-types';
-import type { Fingerprint } from './fingerprint';
+import { type Fingerprint } from './fingerprint';
 import { VisitingQueue } from './visiting-queue';
 import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { SlicingCriteria } from '../criterion/parse';
-import type { REnvironmentInformation } from '../../dataflow/environments/environment';
+import { type SlicingCriteria } from '../criterion/parse';
+import { type REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { SliceDirection } from '../../core/steps/all/static-slicing/00-slice';
 import type { DataflowInformation } from '../../dataflow/info';
@@ -12,12 +12,16 @@ export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogOb
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
- *
  * @param info      - The dataflow information used for slicing.
+ * @param idMap     - The mapping from node ids to their information in the AST.
  * @param criteria  - The criteria to slice on.
  * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
  * @param cache     - A cache to store the results of the slice. If provided, the slice may use this cache to speed up the slicing process.
  */
 export declare function staticSlice(info: DataflowInformation, { idMap }: NormalizedAst, criteria: SlicingCriteria, direction: SliceDirection, threshold?: number, cache?: Map<Fingerprint, Set<NodeId>>): Readonly<SliceResult>;
+/**
+ * Updates the potential addition for the given target node in the visiting queue.
+ * This describes vertices that might be added *if* another path reaches them.
+ */
 export declare function updatePotentialAddition(queue: VisitingQueue, id: NodeId, target: NodeId, baseEnvironment: REnvironmentInformation, envFingerprint: string): void;

package/slicing/static/static-slicer.js

@@ -19,8 +19,8 @@ exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
  * This returns the ids to include in the static slice of the given type, when slicing with the given seed id's (must be at least one).
  * <p>
  * The returned ids can be used to {@link reconstructToCode|reconstruct the slice to R code}.
- *
  * @param info      - The dataflow information used for slicing.
+ * @param idMap     - The mapping from node ids to their information in the AST.
  * @param criteria  - The criteria to slice on.
  * @param direction - The direction to slice in.
  * @param threshold - The maximum number of nodes to visit in the graph. If the threshold is reached, the slice will side with inclusion and drop its minimal guarantee. The limit ensures that the algorithm halts.
@@ -105,6 +105,10 @@ function staticSlice(info, { idMap }, criteria, direction, threshold = 75, cache
     }
     return { ...queue.status(), decodedCriteria };
 }
+/**
+ * Updates the potential addition for the given target node in the visiting queue.
+ * This describes vertices that might be added *if* another path reaches them.
+ */
 function updatePotentialAddition(queue, id, target, baseEnvironment, envFingerprint) {
     const n = queue.potentialAdditions.get(target);
     if (n) {

package/slicing/static/visiting-queue.d.ts

@@ -1,4 +1,4 @@
-import type { Fingerprint } from './fingerprint';
+import { type Fingerprint } from './fingerprint';
 import type { NodeToSlice, SliceResult } from './slicer-types';
 import type { REnvironmentInformation } from '../../dataflow/environments/environment';
 import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';

package/statistics/features/common-syntax-probability.d.ts

@@ -1,4 +1,4 @@
-import type { SummarizedMeasurement } from '../../util/summarizer';
+import { type SummarizedMeasurement } from '../../util/summarizer';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { RArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-argument';
 import type { RNode } from '../../r-bridge/lang-4.x/ast/model/model';
@@ -20,10 +20,19 @@ export interface CommonSyntaxTypeCounts<Measurement = bigint> {
     unaryOp: Record<string, Measurement>;
     other: Record<string, Measurement>;
 }
+/**
+ *
+ */
 export declare function emptyCommonSyntaxTypeCounts<T = bigint>(init?: () => T): CommonSyntaxTypeCounts<T>;
 /**
  * Updates the given counts based on the type of the given node.
  */
 export declare function updateCommonSyntaxTypeCounts(current: CommonSyntaxTypeCounts, ...nodes: (RNode | RArgument)[]): CommonSyntaxTypeCounts;
+/**
+ *
+ */
 export declare function appendCommonSyntaxTypeCounter(a: CommonSyntaxTypeCounts<number[][]>, b: CommonSyntaxTypeCounts): void;
+/**
+ *
+ */
 export declare function summarizeCommonSyntaxTypeCounter(a: CommonSyntaxTypeCounts<number[][]>): CommonSyntaxTypeCounts<SummarizedMeasurement>;

package/statistics/features/common-syntax-probability.js

@@ -11,6 +11,9 @@ const numbers_1 = require("../../util/numbers");
 const summarizer_1 = require("../../util/summarizer");
 const convert_values_1 = require("../../r-bridge/lang-4.x/convert-values");
 const type_1 = require("../../r-bridge/lang-4.x/ast/model/type");
+/**
+ *
+ */
 function emptyCommonSyntaxTypeCounts(init = () => 0n) {
     return {
         total: init(),
@@ -115,6 +118,9 @@ function appendRecord(a, b) {
         get.push([(0, numbers_1.bigint2number)(val)]);
     }
 }
+/**
+ *
+ */
 function appendCommonSyntaxTypeCounter(a, b) {
     a.total.push([(0, numbers_1.bigint2number)(b.total)]);
     a.empty.push([(0, numbers_1.bigint2number)(b.empty)]);
@@ -136,6 +142,9 @@ function appendCommonSyntaxTypeCounter(a, b) {
 function summarizeRecord(a) {
     return Object.fromEntries(Object.entries(a).map(([key, val]) => [key, (0, summarizer_1.summarizeMeasurement)(val.flat(), val.length)]));
 }
+/**
+ *
+ */
 function summarizeCommonSyntaxTypeCounter(a) {
     return {
         total: (0, summarizer_1.summarizeMeasurement)(a.total.flat(), a.total.length),

package/statistics/features/feature.d.ts

@@ -2,7 +2,6 @@
  * This module holds the definition of what a {@link Feature} that can be extracted from an R AST is.
  *
  * Furthermore, it contains the definition of all features that are known in {@link ALL_FEATURES}.
- *
  * @module
  */
 import type { EvalOptions } from 'xpath-ts2/src/parse-api';
@@ -38,9 +37,7 @@ export interface FeatureProcessorInput extends MergeableRecord {
 export type FeatureProcessor<T extends FeatureInfo> = (existing: T, input: FeatureProcessorInput) => T;
 /**
  * A feature is something to be retrieved by the statistics.
- *
  * @typeParam T - The type of what should be collected for the feature
- *
  * @see ALL_FEATURES
  */
 export interface Feature<T extends FeatureInfo> {
@@ -54,7 +51,6 @@ export interface Feature<T extends FeatureInfo> {
      * If present, this feature allows to post-process the results of the feature extraction (for the summarizer).
      * <p>
      * The extraction can use the output path to write files to, and should return the final output.
-     *
      * @param featureRoot - The root path to the feature directory which should contain all the files the feature can write to (already merged for every file processed)
      * @param info        - The feature statistic maps each file name/context encountered to the feature information as well as the meta statistics for the file
      * @param outputPath  - The path to write the output to (besides what is collected in the output and meta information)

package/statistics/features/feature.js

@@ -3,7 +3,6 @@
  * This module holds the definition of what a {@link Feature} that can be extracted from an R AST is.
  *
  * Furthermore, it contains the definition of all features that are known in {@link ALL_FEATURES}.
- *
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/statistics/features/post-processing.d.ts

@@ -5,8 +5,14 @@ export interface SummarizedWithProject<Uniques = Set<string>, Count = number[]>
     uniqueFiles: Uniques;
     count: Count;
 }
+/**
+ *
+ */
 export declare function emptySummarizedWithProject(): SummarizedWithProject;
 export type ReplaceKeysForSummary<Source, Target> = MergeableRecord & {
     [K in keyof Source]: Target;
 };
+/**
+ *
+ */
 export declare function recordFilePath(summarize: SummarizedWithProject, filepath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/post-processing.js

@@ -6,6 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.emptySummarizedWithProject = emptySummarizedWithProject;
 exports.recordFilePath = recordFilePath;
 const path_1 = __importDefault(require("path"));
+/**
+ *
+ */
 function emptySummarizedWithProject() {
     return {
         uniqueProjects: new Set(),
@@ -13,6 +16,9 @@ function emptySummarizedWithProject() {
         count: []
     };
 }
+/**
+ *
+ */
 function recordFilePath(summarize, filepath, config) {
     summarize.uniqueFiles.add(filepath);
     summarize.uniqueProjects.add(filepath.split(path_1.default.sep)[config.projectSkip] ?? '');

package/statistics/features/supported/assignments/assignments.js

@@ -17,7 +17,7 @@ const initialAssignmentInfo = {
 exports.AssignmentOperators = new Set(operators_1.Operators.filter(op => operators_1.OperatorDatabase[op].usedAs === 'assignment'));
 function visitAssignment(info, input) {
     const assignmentStack = [];
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(r => r.root), node => {
         if (node.type !== type_1.RType.BinaryOp || !exports.AssignmentOperators.has(node.operator)) {
             return;
         }

package/statistics/features/supported/assignments/post-process.d.ts

@@ -1,3 +1,6 @@
 import type { FeatureStatisticsWithMeta } from '../../feature';
 import type { StatisticsSummarizerConfiguration } from '../../../summarizer/summarizer';
+/**
+ *
+ */
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/assignments/post-process.js

@@ -101,6 +101,9 @@ function writeAssignmentOperatorsToCsv(outputPath, collected) {
     }
     fnOutStream.close();
 }
+/**
+ *
+ */
 function postProcess(featureRoot, info, outputPath, config) {
     const collected = {
         assignmentOperator: {},

package/statistics/features/supported/comments/post-process.d.ts

@@ -1,3 +1,6 @@
 import type { FeatureStatisticsWithMeta } from '../../feature';
 import type { StatisticsSummarizerConfiguration } from '../../../summarizer/summarizer';
+/**
+ *
+ */
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/comments/post-process.js

@@ -30,6 +30,9 @@ function mapComments(data, fn) {
     }
     return collected;
 }
+/**
+ *
+ */
 function postProcess(featureRoot, info, outputPath, config) {
     // for each we collect the count and the number of files that contain them
     const collected = mapComments(comments_1.initialCommentInfo, initialCommentsMeta);

package/statistics/features/supported/control-flow/control-flow.js

@@ -20,7 +20,7 @@ const initialControlflowInfo = {
 };
 function visitIfThenElse(info, input) {
     const ifThenElseStack = [];
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(f => f.root), node => {
         if (node.type !== type_1.RType.IfThenElse) {
             if (node.type === type_1.RType.FunctionCall && node.named && node.functionName.content === 'switch') {
                 const initialArg = (0, unpack_argument_1.unpackArgument)(node.arguments[0]);

package/statistics/features/supported/control-flow/post-process.d.ts

@@ -1,3 +1,6 @@
 import type { FeatureStatisticsWithMeta } from '../../feature';
 import type { StatisticsSummarizerConfiguration } from '../../../summarizer/summarizer';
+/**
+ *
+ */
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/control-flow/post-process.js

@@ -9,6 +9,9 @@ const post_processing_1 = require("../../post-processing");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const summarizer_1 = require("../../../../util/summarizer");
+/**
+ *
+ */
 function postProcess(featureRoot, info, outputPath, config) {
     const collected = {
         ifThen: (0, common_syntax_probability_1.emptyCommonSyntaxTypeCounts)(() => []),

package/statistics/features/supported/data-access/data-access.d.ts

@@ -1,6 +1,6 @@
 import type { Feature } from '../../feature';
 import type { Writable } from 'ts-essentials';
-import type { CommonSyntaxTypeCounts } from '../../common-syntax-probability';
+import { type CommonSyntaxTypeCounts } from '../../common-syntax-probability';
 declare const initialDataAccessInfo: {
     singleBracket: Record<number, bigint | CommonSyntaxTypeCounts>;
     doubleBracket: Record<number, bigint | CommonSyntaxTypeCounts>;

package/statistics/features/supported/data-access/data-access.js

@@ -46,7 +46,7 @@ function visitAccess(info, input) {
     const accessNest = [];
     const accessChain = [];
     const parentRoleCache = new Map();
-    (0, visitor_1.visitAst)(input.normalizedRAst.ast, node => {
+    (0, visitor_1.visitAst)(input.normalizedRAst.ast.files.map(f => f.root), node => {
         if (node.type !== type_1.RType.Access) {
             return;
         }

package/statistics/features/supported/data-access/post-process.d.ts

@@ -1,3 +1,6 @@
 import type { FeatureStatisticsWithMeta } from '../../feature';
 import type { StatisticsSummarizerConfiguration } from '../../../summarizer/summarizer';
+/**
+ *
+ */
 export declare function postProcess(featureRoot: string, info: Map<string, FeatureStatisticsWithMeta>, outputPath: string, config: StatisticsSummarizerConfiguration): void;

package/statistics/features/supported/data-access/post-process.js

@@ -67,6 +67,9 @@ function writeSingleOrDoubleBrackets(data, outputPath, key) {
         }
     }
 }
+/**
+ *
+ */
 function postProcess(featureRoot, info, outputPath, config) {
     const summarize = {
         singleBracket: new Map(),

package/statistics/features/supported/defined-functions/defined-functions.d.ts

@@ -1,7 +1,7 @@
 import type { Feature } from '../../feature';
 import type { Writable } from 'ts-essentials';
 import type { MergeableRecord } from '../../../../util/objects';
-import type { SourcePosition } from '../../../../util/range';
+import { type SourcePosition } from '../../../../util/range';
 declare const initialFunctionDefinitionInfo: {
     /** all, anonymous, assigned, non-assigned, ... */
     total: number;