@eagleoutice/flowr 2.4.6 → 2.4.8

package/abstract-interpretation/domains/set-bounded-set-domain.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetBoundedSetDomain = void 0;
+const set_1 = require("../../util/collections/set");
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The set bounded set abstract domain as sets capturing possible values of the concrete set bounded by a `limit` for the maximum number of inferred values.
+ * The Bottom element is defined as the{@link Bottom} and the Top element is defined as {@link Top} symbol.
+ * @template T     - Type of the values in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+class SetBoundedSetDomain {
+    limit;
+    _value;
+    constructor(value, limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (value !== lattice_1.Top && value !== lattice_1.Bottom) {
+            this._value = (value.size > limit ? lattice_1.Top : new Set(value));
+        }
+        else {
+            this._value = value;
+        }
+        this.limit = limit;
+    }
+    get value() {
+        return this._value;
+    }
+    static top(limit) {
+        return new SetBoundedSetDomain(lattice_1.Top, limit);
+    }
+    static bottom(limit) {
+        return new SetBoundedSetDomain(lattice_1.Bottom, limit);
+    }
+    static abstract(concrete, limit) {
+        if (concrete === lattice_1.Top) {
+            return SetBoundedSetDomain.top(limit);
+        }
+        else if (concrete.size === 0) {
+            return SetBoundedSetDomain.bottom(limit);
+        }
+        return new SetBoundedSetDomain(concrete.values().reduce((result, set) => result.union(set)), limit);
+    }
+    top() {
+        return SetBoundedSetDomain.top(this.limit);
+    }
+    bottom() {
+        return SetBoundedSetDomain.bottom(this.limit);
+    }
+    equals(other) {
+        return this.value === other.value || (this.isValue() && other.isValue() && (0, set_1.setEquals)(this.value, other.value));
+    }
+    leq(other) {
+        return this.value === lattice_1.Bottom || other.value === lattice_1.Top || (this.isValue() && other.isValue() && this.value.isSubsetOf(other.value));
+    }
+    join(...values) {
+        const result = new SetBoundedSetDomain(this.value, this.limit);
+        for (const other of values) {
+            if (result.value === lattice_1.Top || other.value === lattice_1.Top) {
+                result._value = lattice_1.Top;
+            }
+            else if (result.value === lattice_1.Bottom) {
+                result._value = other.value;
+            }
+            else if (other.value === lattice_1.Bottom) {
+                result._value = result.value;
+            }
+            else {
+                const join = result.value.union(other.value);
+                result._value = join.size > this.limit ? lattice_1.Top : join;
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = new SetBoundedSetDomain(this.value, this.limit);
+        for (const other of values) {
+            if (result.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+                result._value = lattice_1.Bottom;
+            }
+            else if (result.value === lattice_1.Top) {
+                result._value = other.value;
+            }
+            else if (other.value === lattice_1.Top) {
+                result._value = result.value;
+            }
+            else {
+                result._value = result.value.intersection(other.value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Subtracts another abstract value from the current abstract value by removing all elements of the other abstract value from the current abstract value.
+     */
+    subtract(other) {
+        if (this.value === lattice_1.Top) {
+            return this.top();
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        else if (other.value === lattice_1.Top || other.value === lattice_1.Bottom) {
+            return new SetBoundedSetDomain(this.value, this.limit);
+        }
+        else {
+            return new SetBoundedSetDomain(this.value.difference(other.value), this.limit);
+        }
+    }
+    widen(other) {
+        if (this.value === lattice_1.Bottom) {
+            return new SetBoundedSetDomain(other.value, this.limit);
+        }
+        else if (other.value === lattice_1.Bottom) {
+            return new SetBoundedSetDomain(this.value, this.limit);
+        }
+        return other.leq(this) ? new SetBoundedSetDomain(this.value, this.limit) : this.top();
+    }
+    narrow(other) {
+        if (this.value === lattice_1.Bottom || other.value === lattice_1.Bottom) {
+            return this.bottom();
+        }
+        return this.isTop() ? other : this;
+    }
+    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (this.value === lattice_1.Bottom) {
+            return new Set();
+        }
+        else if (this.value === lattice_1.Top || 2 ** (this.value.size) > limit) {
+            return lattice_1.Top;
+        }
+        const subsets = [new Set()];
+        for (const element of this.value.values()) {
+            const newSubsets = subsets.map(subset => new Set([...subset, element]));
+            for (const subset of newSubsets) {
+                subsets.push(subset);
+            }
+        }
+        return new Set(subsets);
+    }
+    abstract(concrete) {
+        return SetBoundedSetDomain.abstract(concrete, this.limit);
+    }
+    toString() {
+        if (this.value === lattice_1.Top) {
+            return '⊤';
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return '⊥';
+        }
+        const string = this.value.values().map(abstract_domain_1.domainElementToString).toArray().join(', ');
+        return `{${string}}`;
+    }
+    isTop() {
+        return this.value === lattice_1.Top;
+    }
+    isBottom() {
+        return this.value == lattice_1.Bottom;
+    }
+    isValue() {
+        return this.value !== lattice_1.Top && this.value !== lattice_1.Bottom;
+    }
+}
+exports.SetBoundedSetDomain = SetBoundedSetDomain;
+//# sourceMappingURL=set-bounded-set-domain.js.map

package/abstract-interpretation/domains/singleton-domain.d.ts

@@ -0,0 +1,38 @@
+import { type AbstractDomain } from './abstract-domain';
+import { Bottom, Top } from './lattice';
+/** The type of the actual values of the singleton domain as single value */
+export type SingletonValue<T> = T;
+/** The type of the Top element of the singleton domain as {@link Top} symbol */
+export type SingletonTop = typeof Top;
+/** The type of the Bottom element of the singleton domain as {@link Bottom} symbol */
+export type SingletonBottom = typeof Bottom;
+/** The type of the abstract values of the singleton domain that are Top, Bottom, or actual values */
+export type SingletonLift<T> = SingletonValue<T> | SingletonTop | SingletonBottom;
+/**
+ * The singleton abstract domain as single possible value.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as {@link Top} symbol.
+ * @template T     - Type of the value in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+export declare class SingletonDomain<T, Value extends SingletonLift<T> = SingletonLift<T>> implements AbstractDomain<T, SingletonValue<T>, SingletonTop, SingletonBottom, Value> {
+    private _value;
+    constructor(value: Value);
+    get value(): Value;
+    static top<T>(): SingletonDomain<T, SingletonTop>;
+    static bottom<T>(): SingletonDomain<T, SingletonBottom>;
+    static abstract<T>(concrete: ReadonlySet<T> | typeof Top): SingletonDomain<T>;
+    top(): SingletonDomain<T, SingletonTop>;
+    bottom(): SingletonDomain<T, SingletonBottom>;
+    equals(other: SingletonDomain<T>): boolean;
+    leq(other: SingletonDomain<T>): boolean;
+    join(...values: SingletonDomain<T>[]): SingletonDomain<T>;
+    meet(...values: SingletonDomain<T>[]): SingletonDomain<T>;
+    widen(other: SingletonDomain<T>): SingletonDomain<T>;
+    narrow(other: SingletonDomain<T>): SingletonDomain<T>;
+    concretize(): ReadonlySet<T> | typeof Top;
+    abstract(concrete: ReadonlySet<T> | typeof Top): SingletonDomain<T>;
+    toString(): string;
+    isTop(): this is SingletonDomain<T, SingletonTop>;
+    isBottom(): this is SingletonDomain<T, SingletonBottom>;
+    isValue(): this is SingletonDomain<T, SingletonValue<T>>;
+}

package/abstract-interpretation/domains/singleton-domain.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * The singleton abstract domain as single possible value.
+ * The Bottom element is defined as {@link Bottom} symbol and the Top element is defined as {@link Top} symbol.
+ * @template T     - Type of the value in the abstract domain
+ * @template Value - Type of the constraint in the abstract domain (Top, Bottom, or an actual value)
+ */
+class SingletonDomain {
+    _value;
+    constructor(value) {
+        this._value = value;
+    }
+    get value() {
+        return this._value;
+    }
+    static top() {
+        return new SingletonDomain(lattice_1.Top);
+    }
+    static bottom() {
+        return new SingletonDomain(lattice_1.Bottom);
+    }
+    static abstract(concrete) {
+        if (concrete === lattice_1.Top || concrete.size > 1) {
+            return SingletonDomain.top();
+        }
+        else if (concrete.size === 0) {
+            return SingletonDomain.bottom();
+        }
+        return new SingletonDomain([...concrete][0]);
+    }
+    top() {
+        return SingletonDomain.top();
+    }
+    bottom() {
+        return SingletonDomain.bottom();
+    }
+    equals(other) {
+        return this.value === other.value;
+    }
+    leq(other) {
+        return this.value === lattice_1.Bottom || other.value === lattice_1.Top || (this.isValue() && other.isValue() && this.value <= other.value);
+    }
+    join(...values) {
+        const result = new SingletonDomain(this.value);
+        for (const other of values) {
+            if (result.value === lattice_1.Bottom) {
+                result._value = other.value;
+            }
+            else if (other.value === lattice_1.Bottom) {
+                result._value = result.value;
+            }
+            else if (result.value !== other.value) {
+                result._value = lattice_1.Top;
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = new SingletonDomain(this.value);
+        for (const other of values) {
+            if (result.value === lattice_1.Top) {
+                result._value = other.value;
+            }
+            else if (other.value === lattice_1.Top) {
+                result._value = result.value;
+            }
+            else if (result.value !== other.value) {
+                result._value = lattice_1.Bottom;
+            }
+        }
+        return result;
+    }
+    widen(other) {
+        return this.join(other); // Using join for widening as the lattice is finite
+    }
+    narrow(other) {
+        return this.meet(other); // Using meet for narrowing as the lattice is finite
+    }
+    concretize() {
+        if (this.value === lattice_1.Top) {
+            return lattice_1.Top;
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return new Set();
+        }
+        return new Set([this.value]);
+    }
+    abstract(concrete) {
+        return SingletonDomain.abstract(concrete);
+    }
+    toString() {
+        if (this.value === lattice_1.Top) {
+            return '⊤';
+        }
+        else if (this.value === lattice_1.Bottom) {
+            return '⊥';
+        }
+        return (0, abstract_domain_1.domainElementToString)(this.value);
+    }
+    isTop() {
+        return this.value === lattice_1.Top;
+    }
+    isBottom() {
+        return this.value === lattice_1.Bottom;
+    }
+    isValue() {
+        return this.value !== lattice_1.Top && this.value !== lattice_1.Bottom;
+    }
+}
+exports.SingletonDomain = SingletonDomain;
+//# sourceMappingURL=singleton-domain.js.map

package/abstract-interpretation/domains/state-abstract-domain.d.ts

@@ -0,0 +1,32 @@
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { AbstractDomain, ConcreteDomain } from './abstract-domain';
+import { Top } from './lattice';
+/** The type of the abstract state for a abstract domain mapping AST node IDs to abstract values of an abstract domain */
+export type AbstractState<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = Map<NodeId, Domain>;
+/** The type of the concrete state for the concrete domain of an abstract domain mapping AST node IDs to a concrete value in the concrete domain */
+export type ConcreteState<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> = ReadonlyMap<NodeId, ConcreteDomain<Domain>>;
+/**
+ * A state abstract domain as mapping of AST node IDs of a program to abstract values of an abstract domain.
+ * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing mapped AST node ID to Top.
+ * @template Domain - Type of the abstract domain to map the AST node IDs to
+ * @see {@link NodeId} for the node IDs of the AST nodes
+ */
+export declare class StateAbstractDomain<Domain extends AbstractDomain<unknown, unknown, unknown, unknown>> implements AbstractDomain<ConcreteState<Domain>, AbstractState<Domain>, AbstractState<Domain>, AbstractState<Domain>> {
+    private _value;
+    constructor(value: AbstractState<Domain>);
+    get value(): AbstractState<Domain>;
+    bottom(): StateAbstractDomain<Domain>;
+    top(): StateAbstractDomain<Domain>;
+    equals(other: StateAbstractDomain<Domain>): boolean;
+    leq(other: StateAbstractDomain<Domain>): boolean;
+    join(...values: StateAbstractDomain<Domain>[]): StateAbstractDomain<Domain>;
+    meet(...values: StateAbstractDomain<Domain>[]): StateAbstractDomain<Domain>;
+    widen(other: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
+    narrow(other: StateAbstractDomain<Domain>): StateAbstractDomain<Domain>;
+    concretize(limit?: number): ReadonlySet<ConcreteState<Domain>> | typeof Top;
+    abstract(concrete: ReadonlySet<ConcreteState<Domain>> | typeof Top): StateAbstractDomain<Domain>;
+    toString(): string;
+    isTop(): this is StateAbstractDomain<Domain>;
+    isBottom(): this is StateAbstractDomain<Domain>;
+    isValue(): this is StateAbstractDomain<Domain>;
+}

package/abstract-interpretation/domains/state-abstract-domain.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateAbstractDomain = void 0;
+const abstract_domain_1 = require("./abstract-domain");
+const lattice_1 = require("./lattice");
+/**
+ * A state abstract domain as mapping of AST node IDs of a program to abstract values of an abstract domain.
+ * The Bottom element is defined as empty mapping and the Top element is defined as mapping every existing mapped AST node ID to Top.
+ * @template Domain - Type of the abstract domain to map the AST node IDs to
+ * @see {@link NodeId} for the node IDs of the AST nodes
+ */
+class StateAbstractDomain {
+    _value;
+    constructor(value) {
+        this._value = new Map(value);
+    }
+    get value() {
+        return this._value;
+    }
+    bottom() {
+        return new StateAbstractDomain(new Map());
+    }
+    top() {
+        const result = new StateAbstractDomain(this.value);
+        for (const [key, value] of result.value) {
+            result._value.set(key, value.top());
+        }
+        return result;
+    }
+    equals(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        else if (this.value.size !== other.value.size) {
+            return false;
+        }
+        for (const [nodeId, value] of this.value) {
+            const otherValue = other.value.get(nodeId);
+            if (otherValue === undefined || !value.equals(otherValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    leq(other) {
+        if (this.value === other.value) {
+            return true;
+        }
+        for (const [nodeId, value] of this.value) {
+            const otherValue = other.value.get(nodeId);
+            if (otherValue === undefined || !value.leq(otherValue)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    join(...values) {
+        const result = new StateAbstractDomain(this.value);
+        for (const other of values) {
+            for (const [nodeId, value] of other.value) {
+                const currValue = result.value.get(nodeId);
+                if (currValue === undefined) {
+                    result.value.set(nodeId, value);
+                }
+                else {
+                    result.value.set(nodeId, currValue.join(value));
+                }
+            }
+        }
+        return result;
+    }
+    meet(...values) {
+        const result = new StateAbstractDomain(this.value);
+        for (const other of values) {
+            for (const [nodeId] of result.value) {
+                if (!other.value.has(nodeId)) {
+                    result.value.delete(nodeId);
+                }
+            }
+            for (const [nodeId, value] of other.value) {
+                const currValue = result.value.get(nodeId);
+                if (currValue !== undefined) {
+                    result.value.set(nodeId, currValue.meet(value));
+                }
+            }
+        }
+        return result;
+    }
+    widen(other) {
+        const result = new StateAbstractDomain(this.value);
+        for (const [nodeId, value] of other.value) {
+            const currValue = result.value.get(nodeId);
+            if (currValue === undefined) {
+                result.value.set(nodeId, value);
+            }
+            else {
+                result.value.set(nodeId, currValue.widen(value));
+            }
+        }
+        return result;
+    }
+    narrow(other) {
+        const result = new StateAbstractDomain(this.value);
+        for (const [nodeId] of this.value) {
+            if (!other.value.has(nodeId)) {
+                result.value.delete(nodeId);
+            }
+        }
+        for (const [nodeId, value] of other.value) {
+            const currValue = result.value.get(nodeId);
+            if (currValue !== undefined) {
+                result.value.set(nodeId, currValue.narrow(value));
+            }
+        }
+        return result;
+    }
+    concretize(limit = abstract_domain_1.DEFAULT_INFERENCE_LIMIT) {
+        if (this.value.values().some(value => value.isBottom())) {
+            return new Set();
+        }
+        let states = new Set([new Map()]);
+        for (const [nodeId, value] of this.value) {
+            const concreteValues = value.concretize(limit);
+            if (concreteValues === lattice_1.Top) {
+                return lattice_1.Top;
+            }
+            const newStates = new Set();
+            for (const state of states) {
+                for (const concrete of concreteValues) {
+                    if (newStates.size > limit) {
+                        return lattice_1.Top;
+                    }
+                    const map = new Map(state);
+                    map.set(nodeId, concrete);
+                    newStates.add(map);
+                }
+            }
+            states = newStates;
+        }
+        return states;
+    }
+    abstract(concrete) {
+        const entry = [...this.value.values()][0];
+        if (concrete === lattice_1.Top || entry === undefined) {
+            return new StateAbstractDomain(new Map());
+        }
+        const mappings = new Map();
+        for (const state of concrete) {
+            for (const [nodeId, value] of state) {
+                const mapping = mappings.get(nodeId);
+                if (mapping === undefined) {
+                    mappings.set(nodeId, new Set([value]));
+                }
+                else {
+                    mapping.add(value);
+                }
+            }
+        }
+        const result = new Map();
+        for (const [nodeId, values] of mappings) {
+            result.set(nodeId, entry.abstract(values));
+        }
+        return new StateAbstractDomain(result);
+    }
+    toString() {
+        return '(' + this.value.entries().toArray().map(([key, value]) => `${key} -> ${value.toString()}`).join(', ') + ')';
+    }
+    isTop() {
+        return this.value.values().every(value => value.isTop());
+    }
+    isBottom() {
+        return this.value.size === 0;
+    }
+    isValue() {
+        return true;
+    }
+}
+exports.StateAbstractDomain = StateAbstractDomain;
+//# sourceMappingURL=state-abstract-domain.js.map

package/benchmark/slicer.js

@@ -108,7 +108,7 @@ class BenchmarkSlicer {
         (0, assert_1.guard)(this.normalizedAst !== undefined, 'normalizedAst should be defined after initialization');
         (0, assert_1.guard)(this.dataflow !== undefined, 'dataflow should be defined after initialization');
         // collect dataflow graph size
-        const vertices = [...this.dataflow.graph.vertices(true)];
+        const vertices = this.dataflow.graph.vertices(true);
         let numberOfEdges = 0;
         let numberOfCalls = 0;
         let numberOfDefinitions = 0;

package/benchmark/summarizer/first-phase/process.js

@@ -256,7 +256,7 @@ async function summarizeSlicerStats(stats, report = () => {
     };
 }
 function summarizeDfShapeStats({ perNodeStats, ...stats }) {
-    const nodeStats = [...perNodeStats.values()];
+    const nodeStats = perNodeStats.values().toArray();
     const isTop = (value) => value === 'top';
     const isInfinite = (value) => value === 'infinite';
     const isBottom = (value) => value === 'bottom';

package/cli/repl/commands/repl-query.js

@@ -37,7 +37,15 @@ async function processQueryArgs(line, parser, output, config) {
     }
     let parsedQuery = [];
     if (query.startsWith('@')) {
-        parsedQuery = [{ type: query.slice(1) }];
+        const queryName = query.slice(1);
+        const queryObj = query_1.SupportedQueries[queryName];
+        if (queryObj?.fromLine) {
+            const q = queryObj.fromLine(args, config);
+            parsedQuery = q ? (Array.isArray(q) ? q : [q]) : [];
+        }
+        else {
+            parsedQuery = [{ type: query.slice(1) }];
+        }
         const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
         if (validationResult.error) {
             output.stderr(`Invalid query: ${validationResult.error.message}`);
@@ -59,6 +67,7 @@ async function processQueryArgs(line, parser, output, config) {
     }
     const processed = await getDataflow(config, parser, args.join(' '));
     return {
+        parsedQuery,
         query: await Promise.resolve((0, query_1.executeQueries)({ dataflow: processed.dataflow, ast: processed.normalize, config }, parsedQuery)),
         processed
     };
@@ -73,7 +82,7 @@ exports.queryCommand = {
         const results = await processQueryArgs(remainingLine, parser, output, config);
         const totalEnd = Date.now();
         if (results) {
-            output.stdout((0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.processed));
+            output.stdout((0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.processed, results.parsedQuery));
         }
     }
 };

package/cli/repl/core.d.ts

@@ -6,8 +6,8 @@ import type { FlowrConfigOptions } from '../../config';
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
-export declare function replCompleter(line: string): [string[], string];
-export declare function makeDefaultReplReadline(): readline.ReadLineOptions;
+export declare function replCompleter(line: string, config: FlowrConfigOptions): [string[], string];
+export declare function makeDefaultReplReadline(config: FlowrConfigOptions): readline.ReadLineOptions;
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *

package/cli/repl/core.js

@@ -60,6 +60,7 @@ const repl_main_1 = require("./commands/repl-main");
 const shell_1 = require("../../r-bridge/shell");
 const log_1 = require("../../util/log");
 const config_1 = require("../../config");
+const query_1 = require("../../queries/query");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
     if (_replCompleterKeywords === undefined) {
@@ -71,7 +72,7 @@ const defaultHistoryFile = path_1.default.join(os_1.default.tmpdir(), '.flowrhis
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
-function replCompleter(line) {
+function replCompleter(line, config) {
     const splitLine = (0, args_1.splitAtEscapeSensitive)(line);
     // did we just type a space (and are starting a new arg right now)?
     const startingNewArg = line.endsWith(' ');
@@ -81,17 +82,19 @@ function replCompleter(line) {
         if (commandNameColon) {
             const completions = [];
             const commandName = commandNameColon.slice(1);
-            if ((0, repl_commands_1.getCommand)(commandName)?.script === true) {
+            const cmd = (0, repl_commands_1.getCommand)(commandName);
+            if (cmd?.script === true) {
                 // autocomplete script arguments
                 const options = scripts_info_1.scripts[commandName].options;
                 completions.push(...(0, scripts_info_1.getValidOptionsForCompletion)(options, splitLine).map(o => `${o} `));
             }
+            else if (commandName.startsWith('query')) {
+                completions.push(...replQueryCompleter(splitLine, config));
+            }
             else {
                 // autocomplete command arguments (specifically, autocomplete the file:// protocol)
                 completions.push(retriever_1.fileProtocol);
             }
-            // add an empty option so that it doesn't autocomplete the only defined option immediately
-            completions.push(' ');
             const currentArg = startingNewArg ? '' : splitLine[splitLine.length - 1];
             return [completions.filter(a => a.startsWith(currentArg)), currentArg];
         }
@@ -99,7 +102,23 @@ function replCompleter(line) {
     // if no command is already typed, just return all commands that match
     return [replCompleterKeywords().filter(k => k.startsWith(line)).map(k => `${k} `), line];
 }
-function makeDefaultReplReadline() {
+function replQueryCompleter(splitLine, config) {
+    const nonEmpty = splitLine.slice(1).map(s => s.trim()).filter(s => s.length > 0);
+    const queryShorts = Object.keys(query_1.SupportedQueries).map(q => `@${q}`).concat(['help']);
+    let candidates = [];
+    if (nonEmpty.length == 0 || (nonEmpty.length == 1 && queryShorts.some(q => q.startsWith(nonEmpty[0]) && nonEmpty[0] !== q))) {
+        candidates = candidates.concat(queryShorts.map(q => `${q} `));
+    }
+    else {
+        const q = nonEmpty[0].slice(1);
+        const queryElement = query_1.SupportedQueries[q];
+        if (queryElement?.completer) {
+            candidates = candidates.concat(queryElement.completer(nonEmpty.slice(1), config));
+        }
+    }
+    return candidates;
+}
+function makeDefaultReplReadline(config) {
     return {
         input: process.stdin,
         output: process.stdout,
@@ -107,7 +126,7 @@ function makeDefaultReplReadline() {
         terminal: true,
         history: loadReplHistory(defaultHistoryFile),
         removeHistoryDuplicates: true,
-        completer: replCompleter
+        completer: (c) => replCompleter(c, config)
     };
 }
 async function replProcessStatement(output, statement, parser, allowRSessionAccess, config) {
@@ -162,7 +181,7 @@ async function replProcessAnswer(config, output, expr, parser, allowRSessionAcce
  * For the execution, this function makes use of {@link replProcessAnswer}.
  *
  */
-async function repl(config, { parser = new shell_1.RShell((0, config_1.getEngineConfig)(config, 'r-shell'), { revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(makeDefaultReplReadline()), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
+async function repl(config, { parser = new shell_1.RShell((0, config_1.getEngineConfig)(config, 'r-shell'), { revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(makeDefaultReplReadline(config)), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
     if (historyFile) {
         rl.on('history', h => fs_1.default.writeFileSync(historyFile, h.join('\n'), { encoding: 'utf-8' }));
     }