@eagleoutice/flowr 2.10.1 → 2.10.2

package/linter/rules/roxygen-arguments.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROXYGEN_ARGS = void 0;
+const linter_format_1 = require("../linter-format");
+const range_1 = require("../../util/range");
+const flowr_search_builder_1 = require("../../search/flowr-search-builder");
+const linter_tags_1 = require("../linter-tags");
+const assert_1 = require("../../util/assert");
+const vertex_1 = require("../../dataflow/graph/vertex");
+const roxygen_ast_1 = require("../../r-bridge/roxygen2/roxygen-ast");
+const r_function_definition_1 = require("../../r-bridge/lang-4.x/ast/model/nodes/r-function-definition");
+const documentation_provider_1 = require("../../r-bridge/roxygen2/documentation-provider");
+function getDocumentation(id, idMap) {
+    const comment = (0, documentation_provider_1.getDocumentationOf)(id, idMap);
+    if (comment === undefined) {
+        return undefined;
+    }
+    return Array.isArray(comment) ? comment : [comment];
+}
+function calculateArgumentDiff(inheritedParams, functionParam, roxygenParam) {
+    //match documented against existing params
+    let underDocumented = new Set(functionParam);
+    const notOverDocumented = underDocumented.has('...');
+    let overDocumented = new Set(roxygenParam);
+    const commonParams = underDocumented.intersection(overDocumented);
+    underDocumented = underDocumented.difference(commonParams);
+    overDocumented = overDocumented.difference(commonParams);
+    //case: '...', overdocumentation not possible
+    if (notOverDocumented) {
+        //if still remaining overdocumented parameters, "..." doesn't need to be documented
+        if (overDocumented.size > 0) {
+            underDocumented.delete('...');
+        }
+        //can't be overdocumented
+        overDocumented.clear();
+    }
+    //inherited params removed from list of overdocumented params
+    overDocumented = overDocumented.difference(new Set(inheritedParams));
+    return underDocumented.size === 0 && overDocumented.size === 0 ? false : { under: Array.from(underDocumented), over: Array.from(overDocumented) };
+}
+exports.ROXYGEN_ARGS = {
+    createSearch: () => flowr_search_builder_1.Q.all().filter(vertex_1.VertexType.FunctionDefinition),
+    processSearchResult: (elements, _config, { normalize }) => {
+        return {
+            results: elements.getElements()
+                .map(element => ({
+                element,
+                underDocumented: [],
+                overDocumented: []
+            }))
+                .filter(({ element: { node }, underDocumented, overDocumented }) => {
+                const comments = getDocumentation(node.info.id, normalize.idMap);
+                if (!comments) {
+                    return false;
+                }
+                const parameters = getParameters(node);
+                //get parameter names
+                const functionParamNames = parameters.map(p => p.name.content.toString());
+                const inheritedParams = comments.filter(tag => (tag?.inherited && tag.type === roxygen_ast_1.KnownRoxygenTags.Param)).map(tag => (tag.value.name));
+                const roxygenParamNames = comments
+                    .filter(tag => tag.type === roxygen_ast_1.KnownRoxygenTags.Param)
+                    .map(tag => tag.value.name);
+                if (functionParamNames === null || roxygenParamNames == null) {
+                    return false;
+                }
+                const result = calculateArgumentDiff(inheritedParams, functionParamNames, roxygenParamNames);
+                if (result === false) {
+                    return false;
+                }
+                underDocumented.push(...result.under);
+                overDocumented.push(...result.over);
+                return true;
+            })
+                .map(({ element, overDocumented, underDocumented }) => ({
+                certainty: linter_format_1.LintingResultCertainty.Uncertain,
+                involvedId: element.node.info.id,
+                loc: range_1.SourceLocation.fromNode(element.node),
+                underDocumented: underDocumented,
+                overDocumented: overDocumented
+            }))
+                .filter(element => (0, assert_1.isNotUndefined)(element.loc)),
+            '.meta': {}
+        };
+    },
+    prettyPrint: {
+        [linter_format_1.LintingPrettyPrintContext.Query]: result => `Code at ${range_1.SourceLocation.format(result.loc)}`,
+        [linter_format_1.LintingPrettyPrintContext.Full]: result => `Code at ${range_1.SourceLocation.format(result.loc)} has undocumented parameters: ${result.underDocumented?.join()} and overdocumented parameters: ${result.overDocumented?.join()}`
+    },
+    info: {
+        name: 'Roxygen Arguments',
+        tags: [linter_tags_1.LintingRuleTag.Smell, linter_tags_1.LintingRuleTag.Documentation, linter_tags_1.LintingRuleTag.Style],
+        certainty: linter_format_1.LintingRuleCertainty.BestEffort,
+        description: 'Checks whether a function has undocumented or overdocumented parameters',
+        defaultConfig: {}
+    }
+};
+function getParameters(node) {
+    return r_function_definition_1.RFunctionDefinition.is(node) ? node.parameters : [];
+}
+//# sourceMappingURL=roxygen-arguments.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.10.1",
+  "version": "2.10.2",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -175,7 +175,6 @@
     "@types/command-line-usage": "^5.0.4",
     "@types/commonmark": "^0.27.10",
     "@types/dagre": "^0.7.53",
-    "@types/n-readlines": "^1.0.6",
     "@types/n3": "^1.26.0",
     "@types/object-hash": "^3.0.6",
     "@types/object-path": "^0.11.4",
@@ -210,7 +209,7 @@
     "gray-matter": "^4.0.3",
     "joi": "^18.0.1",
     "lz-string": "^1.5.0",
-    "n-readlines": "^1.0.3",
+    "n-readlines": "^3.4.1",
     "n3": "^1.26.0",
     "object-hash": "^3.0.0",
     "object-path": "^0.11.8",

package/project/context/flowr-analyzer-context.d.ts

@@ -35,17 +35,12 @@ export interface ReadOnlyFlowrAnalyzerContext {
      * The configuration options used by the analyzer.
      */
     readonly config: FlowrConfig;
-    /**
-     * Run all resolution steps that can be done before the main analysis run.
-     */
-    readonly resolvePreAnalysis: () => void;
 }
 /**
  * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
  * Have a look at the attributes and layers listed below (e.g., {@link files} and {@link deps})
  * to get an idea of the capabilities provided by this context.
- * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods alongside the
- * {@link resolvePreAnalysis} method that conducts all the steps that can be done before the main analysis run.
+ * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods.
  * In general, you do not have to worry about these details, as the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} take care of them.
  *
  * To inspect, e.g., the loading order, you can do so via {@link files.loadingOrder.getLoadingOrder}. To get information on a specific library, use
@@ -71,8 +66,6 @@ export declare class FlowrAnalyzerContext implements ReadOnlyFlowrAnalyzerContex
     addRequests(requests: readonly RAnalysisRequest[]): void;
     addFile(f: string | FlowrFileProvider | RParseRequestFromFile): void;
     addFiles(f: (string | FlowrFileProvider | RParseRequestFromFile)[]): void;
-    /** this conducts all the step that can be done before the main analysis run */
-    resolvePreAnalysis(): void;
     /**
      * Get a read-only version of this context.
      * This is useful if you want to pass the context to a place where you do not want it to be modified or just to reduce

package/project/context/flowr-analyzer-context.js

@@ -18,8 +18,7 @@ const flowr_analyzer_meta_context_1 = require("./flowr-analyzer-meta-context");
  * This summarizes the other context layers used by the {@link FlowrAnalyzer}.
  * Have a look at the attributes and layers listed below (e.g., {@link files} and {@link deps})
  * to get an idea of the capabilities provided by this context.
- * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods alongside the
- * {@link resolvePreAnalysis} method that conducts all the steps that can be done before the main analysis run.
+ * Besides these, this layer only orchestrates the different steps and layers, providing a collection of convenience methods.
  * In general, you do not have to worry about these details, as the {@link FlowrAnalyzerBuilder} and {@link FlowrAnalyzer} take care of them.
  *
  * To inspect, e.g., the loading order, you can do so via {@link files.loadingOrder.getLoadingOrder}. To get information on a specific library, use
@@ -63,11 +62,6 @@ class FlowrAnalyzerContext {
     addFiles(f) {
         this.files.addFiles(f);
     }
-    /** this conducts all the step that can be done before the main analysis run */
-    resolvePreAnalysis() {
-        this.files.computeLoadingOrder();
-        this.deps.resolveStaticDependencies();
-    }
     /**
      * Get a read-only version of this context.
      * This is useful if you want to pass the context to a place where you do not want it to be modified or just to reduce

package/project/context/flowr-analyzer-environment-context.d.ts

@@ -28,6 +28,10 @@ export interface ReadOnlyFlowrAnalyzerEnvironmentContext {
      * Create a new {@link REnvironmentInformation|environment} with an empty built-in environment as base.
      */
     makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+    /**
+     * A completely empty {@link REnvironmentInformation|environment}.
+     */
+    makeEmptyEnv(): REnvironmentInformation;
 }
 /**
  * This context is responsible for providing the built-in environment.
@@ -44,4 +48,5 @@ export declare class FlowrAnalyzerEnvironmentContext implements ReadOnlyFlowrAna
     makeCleanEnv(): REnvironmentInformation;
     getCleanEnvFingerprint(): Fingerprint;
     makeCleanEnvWithEmptyBuiltIns(): REnvironmentInformation;
+    makeEmptyEnv(): REnvironmentInformation;
 }

package/project/context/flowr-analyzer-environment-context.js

@@ -45,6 +45,12 @@ class FlowrAnalyzerEnvironmentContext {
             level: 0
         };
     }
+    makeEmptyEnv() {
+        return {
+            current: new environment_1.Environment(undefined, true),
+            level: 0
+        };
+    }
 }
 exports.FlowrAnalyzerEnvironmentContext = FlowrAnalyzerEnvironmentContext;
 //# sourceMappingURL=flowr-analyzer-environment-context.js.map

package/project/context/flowr-analyzer-files-context.d.ts

@@ -56,6 +56,11 @@ export interface ReadOnlyFlowrAnalyzerFilesContext {
      * @returns An array of all files.
      */
     getAllFiles(): FlowrFileProvider[];
+    /**
+     * Check if the context has a cached file with the given path.
+     * @param path - The path to the file.
+     */
+    hasCached(path: string): boolean;
     /**
      * Check if the context has a file with the given path.
      * Please note, that this may also check the file system, depending on the configuration
@@ -130,6 +135,7 @@ export declare class FlowrAnalyzerFilesContext extends AbstractFlowrAnalyzerCont
     addFile(file: string | FlowrFileProvider | RParseRequestFromFile, roles?: readonly FileRole[]): FlowrFileProvider<{
         toString(): string;
     }>;
+    hasCached(path: string): boolean;
     hasFile(path: string): boolean;
     exists(p: string, ignoreCase: boolean): string | undefined;
     private fileLoadPlugins;

package/project/context/flowr-analyzer-files-context.js

@@ -120,9 +120,11 @@ class FlowrAnalyzerFilesContext extends abstract_flowr_analyzer_context_1.Abstra
         }
         return f;
     }
+    hasCached(path) {
+        return this.files.has(path);
+    }
     hasFile(path) {
-        return this.files.has(path)
-            || (this.ctx.config.project.resolveUnknownPathsOnDisk && fs_1.default.existsSync(path));
+        return this.hasCached(path) || (this.ctx.config.project.resolveUnknownPathsOnDisk && fs_1.default.existsSync(path));
     }
     exists(p, ignoreCase) {
         try {

package/project/flowr-analyzer-builder.js

@@ -157,10 +157,7 @@ class FlowrAnalyzerBuilder {
             context,
             ...(this.input ?? {})
         });
-        const analyzer = new flowr_analyzer_1.FlowrAnalyzer(this.parser, context, cache);
-        // we do it here to save time later if the analyzer is to be duplicated
-        context.resolvePreAnalysis();
-        return analyzer;
+        return new flowr_analyzer_1.FlowrAnalyzer(this.parser, context, cache);
     }
 }
 exports.FlowrAnalyzerBuilder = FlowrAnalyzerBuilder;

package/queries/catalog/call-context-query/call-context-query-executor.d.ts

@@ -2,7 +2,7 @@ import type { CallContextQuery, CallContextQueryResult, CallNameTypes, LinkTo }
 import type { BasicQueryData } from '../../base-query-format';
 export type PromotedCallTest = (t: string) => boolean;
 /**
- *
+ * Convert a name to a predicate that checks whether an input conforms to this name.
  */
 export declare function promoteCallName(callName: CallNameTypes, exact?: boolean): PromotedCallTest;
 export type PromotedLinkTo<LT = LinkTo> = Omit<LT, 'callName'> & {

package/queries/catalog/call-context-query/call-context-query-executor.js

@@ -44,19 +44,24 @@ function isSubCallQuery(query) {
     return 'linkTo' in query && query.linkTo !== undefined;
 }
 /**
- *
+ * Convert a name to a predicate that checks whether an input conforms to this name.
  */
 function promoteCallName(callName, exact = false) {
     if (Array.isArray(callName)) {
         const s = new Set(callName);
         return (t) => s.has(t);
     }
-    else if (exact) {
-        const s = new Set([typeof callName === 'string' ? callName : callName.source]);
-        return (t) => s.has(t);
+    else if (typeof callName === 'string') {
+        if (exact) {
+            return (t) => t === callName;
+        }
+        else {
+            const r = new RegExp(callName);
+            return (t) => r.test(t);
+        }
     }
     else {
-        const r = new RegExp(callName);
+        const r = new RegExp(exact ? '^' + callName.source + '$' : callName.source);
         return (t) => r.test(t);
     }
 }

package/queries/catalog/call-context-query/call-context-query-format.d.ts

@@ -24,7 +24,7 @@ export interface DefaultCallContextQueryFormat<RegexType extends CallNameTypes>
     readonly type: 'call-context';
     /** Regex regarding the function name, please note that strings will be interpreted as regular expressions too! */
     readonly callName: RegexType;
-    /** Should we automatically add the `^` and `$` anchors to the regex to make it an exact match? */
+    /** Should we automatically add the `^` and `$` anchors to the regex to make it an exact match, we now also allow '.' etc. to have their conventional meaning if you pass in the regex as a string? */
     readonly callNameExact?: boolean;
     /** kind may be a step or anything that you attach to the call, this can be used to group calls together (e.g., linking `ggplot` to `visualize`). Defaults to `.` */
     readonly kind?: string;

package/queries/catalog/dependencies-query/function-info/library-functions.js

@@ -7,6 +7,7 @@ exports.LibraryFunctions = [
     { package: 'base', name: 'loadNamespace', argIdx: 0, argName: 'package', resolveValue: true },
     { package: 'base', name: 'attachNamespace', argIdx: 0, argName: 'ns', resolveValue: true },
     { package: 'base', name: 'attach', argIdx: 0, argName: 'what', resolveValue: true },
+    { package: 'base', name: 'use', argIdx: 0, argName: 'package', resolveValue: 'library' },
     { package: 'groundhog', name: 'groundhog.library', argIdx: 0, argName: 'pkg', resolveValue: true },
     { package: 'pacman', name: 'p_load', argIdx: 'unnamed', resolveValue: 'library' },
     { package: 'pacman', name: 'p_load_gh', argIdx: 'unnamed', resolveValue: 'library' },
@@ -15,5 +16,6 @@ exports.LibraryFunctions = [
     { package: 'librarian', name: 'shelf', argIdx: 'unnamed', resolveValue: true },
     { package: 'devtools', name: 'load_all', argIdx: 0, argName: 'path', resolveValue: true, defaultValue: '.' },
     { package: 'devtools', name: 'load_code', argIdx: 0, argName: 'path', resolveValue: true, defaultValue: '.' },
+    { package: 'import', name: 'from', argIdx: 0, argName: 'package', resolveValue: true }
 ];
 //# sourceMappingURL=library-functions.js.map

package/queries/catalog/df-shape-query/df-shape-query-format.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DfShapeQueryDefinition = void 0;
 const joi_1 = __importDefault(require("joi"));
+const abstract_domain_1 = require("../../../abstract-interpretation/domains/abstract-domain");
+const lattice_1 = require("../../../abstract-interpretation/domains/lattice");
 const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
 const ansi_1 = require("../../../util/text/ansi");
 const time_1 = require("../../../util/text/time");
 const df_shape_query_executor_1 = require("./df-shape-query-executor");
-const abstract_domain_1 = require("../../../abstract-interpretation/domains/abstract-domain");
 function dfShapeQueryLineParser(_output, line, _config) {
     const criterion = (0, slice_query_parser_1.sliceCriterionParser)(line[0]);
     return {
@@ -26,6 +27,10 @@ exports.DfShapeQueryDefinition = {
         const out = queryResults;
         const domains = out.domains instanceof abstract_domain_1.AbstractDomain ? out.domains.value : out.domains;
         result.push(`Query: ${(0, ansi_1.bold)('df-shape', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        if (domains === lattice_1.Bottom) {
+            result.push(`   ╰ state: ${lattice_1.BottomSymbol}`);
+            return true;
+        }
         result.push(...domains.entries().take(20).map(([key, domain]) => {
             return `   ╰ ${key}: ${domain?.toString()}`;
         }));
@@ -37,7 +42,7 @@ exports.DfShapeQueryDefinition = {
     jsonFormatter: (queryResults) => {
         const { domains, ...out } = queryResults;
         const state = domains instanceof abstract_domain_1.AbstractDomain ? domains.value : domains;
-        const json = Object.fromEntries(state.entries().map(([key, domain]) => [key, domain?.toJson() ?? null]));
+        const json = state === lattice_1.Bottom ? state.description : Object.fromEntries(state.entries().map(([key, domain]) => [key, domain?.toJson() ?? null]));
         const result = { domains: json, ...out };
         return result;
     },

package/queries/catalog/files-query/files-query-executor.js

@@ -6,7 +6,6 @@ exports.executeFileQuery = executeFileQuery;
  */
 function executeFileQuery({ analyzer }, queries) {
     const start = Date.now();
-    analyzer.inspectContext().resolvePreAnalysis();
     const base = analyzer.inspectContext().files.getAllFiles();
     let files = [];
     const foundFingerprints = new Set();

package/queries/catalog/input-sources-query/simple-input-classifier.d.ts

@@ -4,6 +4,8 @@ import type { MergeableRecord } from '../../../util/objects';
 import { Identifier } from '../../../dataflow/environments/identifier';
 /**
  * Lattice flattening until we have a taint engine :)
+ * Please note that the classifier considers this basis with a set-lift,
+ * joining differing lattice elements.
  *
  *```
  *            [ Unknown ]

package/queries/catalog/input-sources-query/simple-input-classifier.js

@@ -220,6 +220,8 @@ class InputClassifier {
 }
 /**
  * Lattice flattening until we have a taint engine :)
+ * Please note that the classifier considers this basis with a set-lift,
+ * joining differing lattice elements.
  *
  *```
  *            [ Unknown ]

package/r-bridge/data/data.d.ts

@@ -422,9 +422,9 @@ export declare const flowrCapabilities: {
                     readonly description: "_Handle `&&`, `||`, ..._";
                 }, {
                     readonly name: "Pipe and Pipe-Bind";
-                    readonly id: "built-in-pipe-and-pipe-bind";
+                    readonly id: "pipe-and-pipe-bind";
                     readonly supported: "partially";
-                    readonly description: "_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._ We have not enough tests and do not support pipe-bind.";
+                    readonly description: "_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._; Similarly support the other pipe binds";
                 }, {
                     readonly name: "Sequencing";
                     readonly id: "built-in-sequencing";

package/r-bridge/data/data.js

@@ -537,9 +537,9 @@ ${await (0, doc_dfg_1.printDfGraphForCode)(parser, code, { simplified: true })}
                                 },
                                 {
                                     name: 'Pipe and Pipe-Bind',
-                                    id: 'built-in-pipe-and-pipe-bind',
+                                    id: 'pipe-and-pipe-bind',
                                     supported: 'partially',
-                                    description: '_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._ We have not enough tests and do not support pipe-bind.'
+                                    description: '_Handle the [new (4.1) pipe and pipe-bind syntax](https://www.r-bloggers.com/2021/05/the-new-r-pipe/): `|>`, and `=>`._; Similarly support the other pipe binds'
                                 },
                                 {
                                     name: 'Sequencing',

package/r-bridge/lang-4.x/ast/model/nodes/r-argument.d.ts

@@ -4,7 +4,7 @@ import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { ParentInformation } from '../processing/decorate';
 import type { NodeId } from '../processing/node-id';
-import type { RFunctionArgument } from './r-function-call';
+import type { PotentiallyEmptyRArgument } from './r-function-call';
 import { EmptyArgument } from './r-function-call';
 import type { BrandedIdentifier } from '../../../../../dataflow/environments/identifier';
 /**
@@ -33,27 +33,35 @@ export declare const RArgument: {
      * @see {@link RArgument.isUnnamed} - to check whether an argument is unnamed
      */
     readonly is: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RArgument<Info>;
+    /**
+     * Type guard for arguments that are empty, i.e. {@link EmptyArgument}.
+     */
+    readonly isEmpty: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is typeof EmptyArgument;
+    /**
+     * Type guard for arguments that are _not_ empty, i.e. _not_ {@link EmptyArgument}.
+     */
+    readonly isNotEmpty: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is RArgument<Info>;
     /**
      * Type guard for named arguments, i.e. arguments with a name.
      */
-    readonly isNamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RArgument<Info> & {
+    readonly isNamed: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is RArgument<Info> & {
         name: RSymbol<Info, BrandedIdentifier>;
     };
     /**
      * Type guard for unnamed arguments, i.e. arguments without a name.
      */
-    readonly isUnnamed: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RUnnamedArgument<Info>;
+    readonly isUnnamed: <Info = object>(this: void, node: RNode<Info> | typeof EmptyArgument | undefined) => node is RUnnamedArgument<Info>;
     /**
      * Type guard for arguments with a value, i.e. arguments that are not just placeholders without a value.
      */
     readonly isWithValue: <Info = object>(this: void, node: RNode<Info> | undefined) => node is RArgument<Info> & {
         value: RNode<Info>;
     };
-    readonly getWithId: <OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => Exclude<RFunctionArgument<OtherInfo & ParentInformation>, typeof EmptyArgument> | undefined;
+    readonly getWithId: <OtherInfo>(args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => Exclude<PotentiallyEmptyRArgument<OtherInfo & ParentInformation>, typeof EmptyArgument> | undefined;
     /**
      * Retrieve the value of the argument with the given id from the list of arguments.
      */
-    readonly getValue: <OtherInfo>(args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => RNode<OtherInfo> | undefined;
+    readonly getValue: <OtherInfo>(args: readonly PotentiallyEmptyRArgument<OtherInfo & ParentInformation>[], id: NodeId | undefined) => RNode<OtherInfo> | undefined;
     readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
     readonly getId: (this: void, node: RNode<ParentInformation>) => NodeId;
     readonly getType: (this: void, node: RNode) => RType;

package/r-bridge/lang-4.x/ast/model/nodes/r-argument.js

@@ -17,17 +17,29 @@ exports.RArgument = {
     is(node) {
         return node?.type === type_1.RType.Argument;
     },
+    /**
+     * Type guard for arguments that are empty, i.e. {@link EmptyArgument}.
+     */
+    isEmpty(node) {
+        return node === r_function_call_1.EmptyArgument;
+    },
+    /**
+     * Type guard for arguments that are _not_ empty, i.e. _not_ {@link EmptyArgument}.
+     */
+    isNotEmpty(node) {
+        return node !== r_function_call_1.EmptyArgument && exports.RArgument.is(node);
+    },
     /**
      * Type guard for named arguments, i.e. arguments with a name.
      */
     isNamed(node) {
-        return exports.RArgument.is(node) && node.name !== undefined;
+        return node !== r_function_call_1.EmptyArgument && exports.RArgument.is(node) && node.name !== undefined;
     },
     /**
      * Type guard for unnamed arguments, i.e. arguments without a name.
      */
     isUnnamed(node) {
-        return exports.RArgument.is(node) && node.name === undefined && node.value !== undefined;
+        return node !== r_function_call_1.EmptyArgument && exports.RArgument.is(node) && node.name === undefined && node.value !== undefined;
     },
     /**
      * Type guard for arguments with a value, i.e. arguments that are not just placeholders without a value.

package/r-bridge/lang-4.x/ast/model/nodes/r-function-call.d.ts

@@ -4,7 +4,7 @@ import { RType } from '../type';
 import type { RSymbol } from './r-symbol';
 import type { RArgument } from './r-argument';
 export declare const EmptyArgument = "<>";
-export type RFunctionArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArgument;
+export type PotentiallyEmptyRArgument<Info = NoInfo> = RArgument<Info> | typeof EmptyArgument;
 /**
  * Calls of functions like `a()` and `foo(42, "hello")`.
  * @see RUnnamedFunctionCall
@@ -14,7 +14,7 @@ export interface RNamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>, L
     readonly named: true;
     functionName: RSymbol<Info>;
     /** arguments can be empty, for example when calling as `a(1, ,3)` */
-    readonly arguments: readonly RFunctionArgument<Info>[];
+    readonly arguments: readonly PotentiallyEmptyRArgument<Info>[];
 }
 /**
  * Direct calls of functions like `(function(x) { x })(3)`.
@@ -27,7 +27,7 @@ export interface RUnnamedFunctionCall<Info = NoInfo> extends RAstNodeBase<Info>,
     /** marks function calls like `3 %xx% 4` which have been written in special infix notation; deprecated in v2 */
     infixSpecial?: boolean;
     /** arguments can be undefined, for example when calling as `a(1, ,3)` */
-    readonly arguments: readonly RFunctionArgument<Info>[];
+    readonly arguments: readonly PotentiallyEmptyRArgument<Info>[];
 }
 export type RFunctionCall<Info = NoInfo> = RNamedFunctionCall<Info> | RUnnamedFunctionCall<Info>;
 /**

package/r-bridge/lang-4.x/ast/model/nodes/r-pipe.d.ts

@@ -23,6 +23,15 @@ export declare const RPipe: {
      * Returns the minimum R version that supports the pipe operator.
      */
     readonly availableFromRVersion: (this: void) => SemVer;
+    /**
+     * Returns the minimum R version that supports using the placeholder like '_'.
+     */
+    readonly hasPlaceHolderFromRVersion: (this: void) => SemVer;
+    /**
+     * Returns the minimum R version that supports using the placeholder like '_' in access
+     * patterns: `_$a`
+     */
+    readonly hasAccessPlaceHolderFromRVersion: (this: void) => SemVer;
     readonly getLocation: (this: void, node: RNode) => import("../../../../../util/range").SourceLocation | undefined;
     readonly getId: (this: void, node: RNode<import("../processing/decorate").ParentInformation>) => import("../processing/node-id").NodeId;
     readonly getType: (this: void, node: RNode) => RType;

package/r-bridge/lang-4.x/ast/model/nodes/r-pipe.js

@@ -23,5 +23,18 @@ exports.RPipe = {
     availableFromRVersion() {
         return new semver_1.SemVer(versions_1.MIN_VERSION_PIPE);
     },
+    /**
+     * Returns the minimum R version that supports using the placeholder like '_'.
+     */
+    hasPlaceHolderFromRVersion() {
+        return new semver_1.SemVer(versions_1.MIN_VERSION_PIPE_PLACEHOLDER);
+    },
+    /**
+     * Returns the minimum R version that supports using the placeholder like '_' in access
+     * patterns: `_$a`
+     */
+    hasAccessPlaceHolderFromRVersion() {
+        return new semver_1.SemVer(versions_1.MIN_VERSION_PIPE_PLACEHOLDER_EXTRACT);
+    }
 };
 //# sourceMappingURL=r-pipe.js.map

package/r-bridge/lang-4.x/ast/model/versions.d.ts

@@ -4,5 +4,7 @@
  */
 export declare const MIN_VERSION_PIPE = "4.1.0";
 export declare const MIN_VERSION_LAMBDA = "4.1.0";
+export declare const MIN_VERSION_PIPE_PLACEHOLDER = "4.2.0";
+export declare const MIN_VERSION_PIPE_PLACEHOLDER_EXTRACT = "4.3.0";
 /** between 4.0.0 and (i think) 4.1.0 the parser handled them differently. We ignore that for now. */
 export declare const MIN_VERSION_RAW_STABLE = "4.1.0";

package/r-bridge/lang-4.x/ast/model/versions.js

@@ -4,9 +4,11 @@
  * @module
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MIN_VERSION_RAW_STABLE = exports.MIN_VERSION_LAMBDA = exports.MIN_VERSION_PIPE = void 0;
+exports.MIN_VERSION_RAW_STABLE = exports.MIN_VERSION_PIPE_PLACEHOLDER_EXTRACT = exports.MIN_VERSION_PIPE_PLACEHOLDER = exports.MIN_VERSION_LAMBDA = exports.MIN_VERSION_PIPE = void 0;
 exports.MIN_VERSION_PIPE = '4.1.0';
 exports.MIN_VERSION_LAMBDA = '4.1.0';
+exports.MIN_VERSION_PIPE_PLACEHOLDER = '4.2.0';
+exports.MIN_VERSION_PIPE_PLACEHOLDER_EXTRACT = '4.3.0';
 /** between 4.0.0 and (i think) 4.1.0 the parser handled them differently. We ignore that for now. */
 exports.MIN_VERSION_RAW_STABLE = '4.1.0';
 //# sourceMappingURL=versions.js.map

package/r-bridge/roxygen2/documentation-provider.js

@@ -85,30 +85,39 @@ function getDocumentationOfByName(name, idMap) {
         return getDocumentationOf(node.info.id, idMap);
     }
 }
-function filterDocumentationForParams(doc, filter) {
+function filterDocumentationForParamsInherited(doc, filter) {
     if (!doc) {
         return doc;
     }
     if (Array.isArray(doc)) {
-        return doc.filter(filter);
+        const ds = doc.filter(filter);
+        for (const d of ds) {
+            d.inherited = true;
+        }
+        return ds;
     }
     else {
-        return filter(doc) ? doc : undefined;
+        const d = doc;
+        if (filter(d)) {
+            d.inherited = true;
+            return d;
+        }
+        return undefined;
     }
 }
 function expandInheritOfTag(tag, otherTags, idMap) {
     if (tag.type === roxygen_ast_1.KnownRoxygenTags.Inherit) {
         const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
-        return filterDocumentationForParams(inheritDoc, t => tag.value.components.includes(t.type));
+        return filterDocumentationForParamsInherited(inheritDoc, t => tag.value.components.includes(t.type));
     }
     else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritDotParams) {
         const inheritDoc = getDocumentationOfByName(tag.value.source, idMap);
-        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === '...');
+        return filterDocumentationForParamsInherited(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && t.value.name === '...');
     }
     else if (tag.type === roxygen_ast_1.KnownRoxygenTags.InheritParams) {
         const inheritDoc = getDocumentationOfByName(tag.value, idMap);
         const alreadyExplainedParams = new Set(otherTags.filter(t => t.type === roxygen_ast_1.KnownRoxygenTags.Param).map(t => t.value.name));
-        return filterDocumentationForParams(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && !alreadyExplainedParams.has(t.value.name));
+        return filterDocumentationForParamsInherited(inheritDoc, t => t.type === roxygen_ast_1.KnownRoxygenTags.Param && !alreadyExplainedParams.has(t.value.name));
     }
     return tag;
 }