@eagleoutice/flowr 2.1.1 → 2.1.2

package/queries/catalog/id-map-query/id-map-query-executor.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeIdMapQuery = executeIdMapQuery;
+const log_1 = require("../../../util/log");
+function executeIdMapQuery({ ast }, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('Id-Map query expects only up to one query, but got', queries.length);
+    }
+    return {
+        '.meta': {
+            /* there is no sense in measuring a get */
+            timing: 0
+        },
+        idMap: ast.idMap
+    };
+}
+//# sourceMappingURL=id-map-query-executor.js.map

package/queries/catalog/id-map-query/id-map-query-format.d.ts

@@ -0,0 +1,8 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { AstIdMap } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export interface IdMapQuery extends BaseQueryFormat {
+    readonly type: 'id-map';
+}
+export interface IdMapQueryResult extends BaseQueryResult {
+    readonly idMap: AstIdMap;
+}

package/{r-bridge/lang-4.x/ast/parser/xml/normalizer-data.js → queries/catalog/id-map-query/id-map-query-format.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=normalizer-data.js.map
+//# sourceMappingURL=id-map-query-format.js.map

package/queries/catalog/normalized-ast-query/normalized-ast-query-executor.d.ts

@@ -0,0 +1,3 @@
+import type { BasicQueryData } from '../../query';
+import type { NormalizedAstQuery, NormalizedAstQueryResult } from './normalized-ast-query-format';
+export declare function executeNormalizedAstQuery({ ast }: BasicQueryData, queries: readonly NormalizedAstQuery[]): NormalizedAstQueryResult;

package/queries/catalog/normalized-ast-query/normalized-ast-query-executor.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeNormalizedAstQuery = executeNormalizedAstQuery;
+const log_1 = require("../../../util/log");
+function executeNormalizedAstQuery({ ast }, queries) {
+    if (queries.length !== 1) {
+        log_1.log.warn('Normalized-Ast query expects only up to one query, but got', queries.length);
+    }
+    return {
+        '.meta': {
+            /* there is no sense in measuring a get */
+            timing: 0
+        },
+        normalized: ast
+    };
+}
+//# sourceMappingURL=normalized-ast-query-executor.js.map

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.d.ts

@@ -0,0 +1,11 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { NormalizedAst } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+/**
+ * Simple re-returns the normalized AST of the analysis.
+ */
+export interface NormalizedAstQuery extends BaseQueryFormat {
+    readonly type: 'normalized-ast';
+}
+export interface NormalizedAstQueryResult extends BaseQueryResult {
+    readonly normalized: NormalizedAst;
+}

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=normalized-ast-query-format.js.map

package/queries/catalog/static-slice-query/static-slice-query-executor.d.ts

@@ -0,0 +1,4 @@
+import type { BasicQueryData } from '../../query';
+import type { StaticSliceQuery, StaticSliceQueryResult } from './static-slice-query-format';
+export declare function fingerPrintOfQuery(query: StaticSliceQuery): string;
+export declare function executeStaticSliceClusterQuery({ graph, ast }: BasicQueryData, queries: readonly StaticSliceQuery[]): StaticSliceQueryResult;

package/queries/catalog/static-slice-query/static-slice-query-executor.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerPrintOfQuery = fingerPrintOfQuery;
+exports.executeStaticSliceClusterQuery = executeStaticSliceClusterQuery;
+const static_slicer_1 = require("../../../slicing/static/static-slicer");
+const reconstruct_1 = require("../../../reconstruct/reconstruct");
+const auto_select_defaults_1 = require("../../../reconstruct/auto-select/auto-select-defaults");
+const magic_comments_1 = require("../../../reconstruct/auto-select/magic-comments");
+const log_1 = require("../../../util/log");
+function fingerPrintOfQuery(query) {
+    return JSON.stringify(query);
+}
+function executeStaticSliceClusterQuery({ graph, ast }, queries) {
+    const start = Date.now();
+    const results = {};
+    for (const query of queries) {
+        const key = fingerPrintOfQuery(query);
+        if (results[key]) {
+            log_1.log.warn(`Duplicate Key for slicing-query: ${key}, skipping...`);
+        }
+        const { criteria, noReconstruction, noMagicComments } = query;
+        const slice = (0, static_slicer_1.staticSlicing)(graph, ast, criteria);
+        if (noReconstruction) {
+            results[key] = { slice };
+        }
+        else {
+            results[key] = {
+                slice,
+                reconstruct: (0, reconstruct_1.reconstructToCode)(ast, slice.result, noMagicComments ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect))
+            };
+        }
+    }
+    return {
+        '.meta': {
+            timing: Date.now() - start
+        },
+        results
+    };
+}
+//# sourceMappingURL=static-slice-query-executor.js.map

package/queries/catalog/static-slice-query/static-slice-query-format.d.ts

@@ -0,0 +1,24 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
+import type { DEFAULT_DATAFLOW_PIPELINE, DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE, DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
+import type { SlicingCriteria } from '../../../slicing/criterion/parse';
+/** Calculates and returns all clusters encountered in the dataflow graph. */
+export interface StaticSliceQuery extends BaseQueryFormat {
+    readonly type: 'static-slice';
+    /** The slicing criteria to use */
+    readonly criteria: SlicingCriteria;
+    /** do not reconstruct the slice into readable code */
+    readonly noReconstruction?: boolean;
+    /** Should the magic comments (force-including lines within the slice) be ignored? */
+    readonly noMagicComments?: boolean;
+}
+export interface StaticSliceQueryResult extends BaseQueryResult {
+    /**
+     * only contains the results of the slice steps to not repeat ourselves, this does not contain the reconstruction
+     * if you set the {@link SliceQuery#noReconstruction|noReconstruction} flag.
+     *
+     * The keys are serialized versions of the used queries (i.e., the result of `JSON.stringify`).
+     * This implies that multiple slice queries with the same query configuration will _not_ be re-executed.
+     */
+    results: Record<string, Omit<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>, keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>> | Omit<PipelineOutput<typeof DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE>, keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>>>;
+}

package/queries/catalog/static-slice-query/static-slice-query-format.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=static-slice-query-format.js.map

package/queries/query-schema.d.ts

@@ -1,5 +1,10 @@
 import Joi from 'joi';
 export declare const CallContextQuerySchema: Joi.ObjectSchema<any>;
+export declare const DataflowQuerySchema: Joi.ObjectSchema<any>;
+export declare const IdMapQuerySchema: Joi.ObjectSchema<any>;
+export declare const NormalizedAstQuerySchema: Joi.ObjectSchema<any>;
+export declare const DataflowClusterQuerySchema: Joi.ObjectSchema<any>;
+export declare const StaticSliceQuerySchema: Joi.ObjectSchema<any>;
 export declare const SupportedQueriesSchema: Joi.AlternativesSchema<any>;
 export declare const CompoundQuerySchema: Joi.ObjectSchema<any>;
 export declare const VirtualQuerySchema: Joi.AlternativesSchema<any>;

package/queries/query-schema.js

@@ -3,12 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueriesSchema = exports.AnyQuerySchema = exports.VirtualQuerySchema = exports.CompoundQuerySchema = exports.SupportedQueriesSchema = exports.CallContextQuerySchema = void 0;
+exports.QueriesSchema = exports.AnyQuerySchema = exports.VirtualQuerySchema = exports.CompoundQuerySchema = exports.SupportedQueriesSchema = exports.StaticSliceQuerySchema = exports.DataflowClusterQuerySchema = exports.NormalizedAstQuerySchema = exports.IdMapQuerySchema = exports.DataflowQuerySchema = exports.CallContextQuerySchema = void 0;
 const joi_1 = __importDefault(require("joi"));
-const call_context_query_format_1 = require("./call-context-query/call-context-query-format");
+const call_context_query_format_1 = require("./catalog/call-context-query/call-context-query-format");
 exports.CallContextQuerySchema = joi_1.default.object({
     type: joi_1.default.string().valid('call-context').required().description('The type of the query.'),
     callName: joi_1.default.string().required().description('Regex regarding the function name!'),
+    callNameExact: joi_1.default.boolean().optional().description('Should we automatically add the `^` and `$` anchors to the regex to make it an exact match?'),
     kind: joi_1.default.string().optional().description('The kind of the call, this can be used to group calls together (e.g., linking `plot` to `visualize`). Defaults to `.`'),
     subkind: joi_1.default.string().optional().description('The subkind of the call, this can be used to uniquely identify the respective call type when grouping the output (e.g., the normalized name, linking `ggplot` to `plot`). Defaults to `.`'),
     callTargets: joi_1.default.string().valid(...Object.values(call_context_query_format_1.CallTargets)).optional().description('Call targets the function may have. This defaults to `any`. Request this specifically to gain all call targets we can resolve.'),
@@ -18,7 +19,25 @@ exports.CallContextQuerySchema = joi_1.default.object({
         callName: joi_1.default.string().required().description('Regex regarding the function name of the last call. Similar to `callName`, strings are interpreted as a regular expression.')
     }).optional().description('Links the current call to the last call of the given kind. This way, you can link a call like `points` to the latest graphics plot etc.')
 }).description('Call context query used to find calls in the dataflow graph');
-exports.SupportedQueriesSchema = joi_1.default.alternatives(exports.CallContextQuerySchema).description('Supported queries');
+exports.DataflowQuerySchema = joi_1.default.object({
+    type: joi_1.default.string().valid('dataflow').required().description('The type of the query.'),
+}).description('The dataflow query simply returns the dataflow graph, there is no need to pass it multiple times!');
+exports.IdMapQuerySchema = joi_1.default.object({
+    type: joi_1.default.string().valid('id-map').required().description('The type of the query.'),
+}).description('The id map query retrieves the id map from the normalized AST.');
+exports.NormalizedAstQuerySchema = joi_1.default.object({
+    type: joi_1.default.string().valid('normalized-ast').required().description('The type of the query.'),
+}).description('The normalized AST query simply returns the normalized AST, there is no need to pass it multiple times!');
+exports.DataflowClusterQuerySchema = joi_1.default.object({
+    type: joi_1.default.string().valid('dataflow-cluster').required().description('The type of the query.'),
+}).description('The cluster query calculates and returns all clusters in the dataflow graph.');
+exports.StaticSliceQuerySchema = joi_1.default.object({
+    type: joi_1.default.string().valid('static-slice').required().description('The type of the query.'),
+    criteria: joi_1.default.array().items(joi_1.default.string()).min(0).required().description('The slicing criteria to use.'),
+    noReconstruction: joi_1.default.boolean().optional().description('Do not reconstruct the slice into readable code.'),
+    noMagicComments: joi_1.default.boolean().optional().description('Should the magic comments (force-including lines within the slice) be ignored?')
+}).description('Slice query used to slice the dataflow graph');
+exports.SupportedQueriesSchema = joi_1.default.alternatives(exports.CallContextQuerySchema, exports.DataflowQuerySchema, exports.IdMapQuerySchema, exports.NormalizedAstQuerySchema, exports.DataflowClusterQuerySchema, exports.StaticSliceQuerySchema).description('Supported queries');
 exports.CompoundQuerySchema = joi_1.default.object({
     type: joi_1.default.string().valid('compound').required().description('The type of the query.'),
     query: joi_1.default.string().required().description('The query to run on the file analysis information.'),

package/queries/query.d.ts

@@ -1,11 +1,21 @@
-import type { CallContextQuery } from './call-context-query/call-context-query-format';
+import type { CallContextQuery } from './catalog/call-context-query/call-context-query-format';
 import type { DataflowGraph } from '../dataflow/graph/graph';
 import type { BaseQueryFormat, BaseQueryResult } from './base-query-format';
-import { executeCallContextQueries } from './call-context-query/call-context-query-executor';
+import { executeCallContextQueries } from './catalog/call-context-query/call-context-query-executor';
 import type { VirtualQueryArgumentsWithType } from './virtual-query/virtual-queries';
 import type { VirtualCompoundConstraint } from './virtual-query/compound-query';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-export type Query = CallContextQuery;
+import { executeDataflowQuery } from './catalog/dataflow-query/dataflow-query-executor';
+import type { DataflowQuery } from './catalog/dataflow-query/dataflow-query-format';
+import { executeIdMapQuery } from './catalog/id-map-query/id-map-query-executor';
+import type { IdMapQuery } from './catalog/id-map-query/id-map-query-format';
+import { executeNormalizedAstQuery } from './catalog/normalized-ast-query/normalized-ast-query-executor';
+import type { NormalizedAstQuery } from './catalog/normalized-ast-query/normalized-ast-query-format';
+import type { DataflowClusterQuery } from './catalog/cluster-query/cluster-query-format';
+import { executeDataflowClusterQuery } from './catalog/cluster-query/cluster-query-executor';
+import type { StaticSliceQuery } from './catalog/static-slice-query/static-slice-query-format';
+import { executeStaticSliceClusterQuery } from './catalog/static-slice-query/static-slice-query-executor';
+export type Query = CallContextQuery | DataflowQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -19,6 +29,11 @@ type SupportedQueries = {
 };
 export declare const SupportedQueries: {
     readonly 'call-context': typeof executeCallContextQueries;
+    readonly dataflow: typeof executeDataflowQuery;
+    readonly 'id-map': typeof executeIdMapQuery;
+    readonly 'normalized-ast': typeof executeNormalizedAstQuery;
+    readonly 'dataflow-cluster': typeof executeDataflowClusterQuery;
+    readonly 'static-slice': typeof executeStaticSliceClusterQuery;
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;
 export type QueryResult<Type extends Query['type']> = ReturnType<typeof SupportedQueries[Type]>;
@@ -27,7 +42,7 @@ export type QueryResults<Base extends SupportedQueryTypes> = {
     readonly [QueryType in Base]: QueryResult<QueryType>;
 } & BaseQueryResult;
 type OmitFromValues<T, K extends string | number | symbol> = {
-    [P in keyof T]: Omit<T[P], K>;
+    [P in keyof T]?: Omit<T[P], K>;
 };
 export type QueryResultsWithoutMeta<Queries extends Query> = OmitFromValues<Omit<QueryResults<Queries['type']>, '.meta'>, '.meta'>;
 export type Queries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = readonly (QueryArgumentsWithType<Base> | VirtualQueryArgumentsWithType<Base, VirtualArguments>)[];

package/queries/query.js

@@ -3,11 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SupportedQueries = void 0;
 exports.executeQueriesOfSameType = executeQueriesOfSameType;
 exports.executeQueries = executeQueries;
-const call_context_query_executor_1 = require("./call-context-query/call-context-query-executor");
+const call_context_query_executor_1 = require("./catalog/call-context-query/call-context-query-executor");
 const assert_1 = require("../util/assert");
 const virtual_queries_1 = require("./virtual-query/virtual-queries");
+const dataflow_query_executor_1 = require("./catalog/dataflow-query/dataflow-query-executor");
+const id_map_query_executor_1 = require("./catalog/id-map-query/id-map-query-executor");
+const normalized_ast_query_executor_1 = require("./catalog/normalized-ast-query/normalized-ast-query-executor");
+const cluster_query_executor_1 = require("./catalog/cluster-query/cluster-query-executor");
+const static_slice_query_executor_1 = require("./catalog/static-slice-query/static-slice-query-executor");
 exports.SupportedQueries = {
-    'call-context': call_context_query_executor_1.executeCallContextQueries
+    'call-context': call_context_query_executor_1.executeCallContextQueries,
+    'dataflow': dataflow_query_executor_1.executeDataflowQuery,
+    'id-map': id_map_query_executor_1.executeIdMapQuery,
+    'normalized-ast': normalized_ast_query_executor_1.executeNormalizedAstQuery,
+    'dataflow-cluster': cluster_query_executor_1.executeDataflowClusterQuery,
+    'static-slice': static_slice_query_executor_1.executeStaticSliceClusterQuery
 };
 function executeQueriesOfSameType(data, ...queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');

package/r-bridge/lang-4.x/ast/parser/json/format.d.ts

@@ -1,17 +1,41 @@
+import { RawRType } from '../../model/type';
 export declare const RootId = 0;
-export interface Entry extends Record<string, unknown> {
-    line1: number;
-    col1: number;
-    line2: number;
-    col2: number;
-    id: number;
-    parent: number;
-    token: string;
-    terminal: boolean;
-    text: string;
-    children?: Entry[];
+/**
+ * Entry type - shared between CSV and JSON entries.
+ * These include position, token, and text.
+ */
+interface Entry extends Record<string, unknown> {
+    readonly line1: number;
+    readonly col1: number;
+    readonly line2: number;
+    readonly col2: number;
+    readonly token: string;
+    readonly text: string;
+}
+/**
+ * CsvEntry type - mapping of ParsedDataRow to a JS object structure.
+ * Contains construction information - whether we deal with a terminal, IDs, and children.
+ */
+export interface CsvEntry extends Entry {
+    readonly id: number;
+    readonly parent: number;
+    readonly terminal: boolean;
+    children?: CsvEntry[];
 }
 /**
- * Parses the given data and sets child relationship, return the list of root entries (with a parent of {@link RootId}).
+ * Type-safe object structure that we work with during normalization.
+ * Has Children (empty list indicates no children).
  */
-export declare function prepareParsedData(data: string): Entry[];
+export interface JsonEntry extends Entry {
+    readonly children: JsonEntry[];
+}
+/**
+ * Named JSON entries - these also have a RawRType assigned to them.
+ */
+export interface NamedJsonEntry {
+    name: RawRType;
+    content: JsonEntry;
+}
+export declare function prepareParsedData(data: string): CsvEntry[];
+export declare function convertPreparedParsedData(roots: readonly CsvEntry[]): JsonEntry;
+export {};

package/r-bridge/lang-4.x/ast/parser/json/format.js

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RootId = void 0;
 exports.prepareParsedData = prepareParsedData;
+exports.convertPreparedParsedData = convertPreparedParsedData;
 const retriever_1 = require("../../../../retriever");
 const assert_1 = require("../../../../../util/assert");
+const type_1 = require("../../model/type");
 exports.RootId = 0;
-/**
- * Parses the given data and sets child relationship, return the list of root entries (with a parent of {@link RootId}).
- */
 function prepareParsedData(data) {
     let json;
     try {
@@ -26,9 +25,10 @@ function prepareParsedData(data) {
         if (entry.parent != exports.RootId) {
             /** it turns out that comments may return a negative id pair to their parent */
             const parent = ret.get(Math.abs(entry.parent));
-            (0, assert_1.guard)(parent !== undefined, () => `Could not find parent ${entry.parent} for entry ${entry.id}`);
-            parent.children ??= [];
-            parent.children.push(entry);
+            if (parent) {
+                parent.children ??= [];
+                parent.children.push(entry);
+            }
         }
         else {
             roots.push(entry);
@@ -36,4 +36,57 @@ function prepareParsedData(data) {
     }
     return roots;
 }
+function convertPreparedParsedData(roots) {
+    const partialEntry = {
+        token: type_1.RawRType.ExpressionList,
+        text: '',
+        id: exports.RootId,
+        parent: exports.RootId
+    };
+    // if we don't have children, this is simple
+    if (roots.length <= 0) {
+        return {
+            ...partialEntry,
+            line1: 1,
+            col1: 1,
+            line2: 1,
+            col2: 1,
+            children: []
+        };
+    }
+    // Locate start, end of a source file (order children in advance).
+    const rootEntries = [...roots].sort(orderOf);
+    const start = rootEntries[0];
+    const end = rootEntries[rootEntries.length - 1];
+    // Construct CsvEntry for the root, handling empty input.
+    const csvParent = {
+        ...partialEntry,
+        line1: start?.line1 ?? 1,
+        col1: start?.col1 ?? 1,
+        line2: end?.line2 ?? 1,
+        col2: end?.col2 ?? 1,
+        children: rootEntries,
+        terminal: false
+    };
+    // Return actual value.
+    return convertEntry(csvParent);
+}
+function convertEntry(csvEntry) {
+    return {
+        ...csvEntry,
+        // check and recursively iterate children
+        children: csvEntry.children?.sort(orderOf).map(convertEntry) ?? []
+    };
+}
+/**
+ * we sort children the same way xmlparsedata does (by line, by column, by inverse end line, by inverse end column, by terminal state, by combined "start" tiebreaker value)
+ * (https://github.com/r-lib/xmlparsedata/blob/v1.0.5/R/package.R#L120)
+ */
+function orderOf(c1, c2) {
+    return c1.line1 - c2.line1 || c1.col1 - c2.col1 || c2.line2 - c1.line2 || c2.col2 - c1.col2 || Number(c1.terminal) - Number(c2.terminal) || sortTiebreak(c1) - sortTiebreak(c2);
+}
+function sortTiebreak({ line1, col1, col2 }) {
+    // see https://github.com/r-lib/xmlparsedata/blob/v1.0.5/R/package.R#L86
+    return line1 * (Math.max(col1, col2) + 1) + col1;
+}
 //# sourceMappingURL=format.js.map

package/r-bridge/lang-4.x/ast/parser/json/parser.d.ts

@@ -1,7 +1,4 @@
-import type { Entry } from './format';
 import type { IdGenerator, NormalizedAst } from '../../model/processing/decorate';
 import type { NoInfo } from '../../model/model';
-import type { XmlBasedJson } from '../xml/input-format';
 export declare const parseLog: import("tslog").Logger<import("tslog").ILogObj>;
 export declare function normalize(jsonString: string, getId?: IdGenerator<NoInfo>): NormalizedAst;
-export declare function convertPreparedParsedData(rootEntries: Entry[]): XmlBasedJson;

package/r-bridge/lang-4.x/ast/parser/json/parser.js

@@ -2,52 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseLog = void 0;
 exports.normalize = normalize;
-exports.convertPreparedParsedData = convertPreparedParsedData;
 const format_1 = require("./format");
 const log_1 = require("../../../../../util/log");
 const decorate_1 = require("../../model/processing/decorate");
-const normalize_root_1 = require("../xml/internal/structure/normalize-root");
-const input_format_1 = require("../xml/input-format");
-const type_1 = require("../../model/type");
+const normalize_root_1 = require("../main/internal/structure/normalize-root");
 exports.parseLog = log_1.log.getSubLogger({ name: 'ast-parser' });
 function normalize(jsonString, getId = (0, decorate_1.deterministicCountingIdGenerator)(0)) {
     const data = { currentRange: undefined, currentLexeme: undefined };
-    const object = convertPreparedParsedData((0, format_1.prepareParsedData)(jsonString));
+    const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(jsonString));
     return (0, decorate_1.decorateAst)((0, normalize_root_1.normalizeRootObjToAst)(data, object), getId);
 }
-function convertPreparedParsedData(rootEntries) {
-    return {
-        [type_1.RawRType.ExpressionList]: {
-            [input_format_1.nameKey]: type_1.RawRType.ExpressionList,
-            [input_format_1.childrenKey]: rootEntries.map(convertEntry)
-        }
-    };
-}
-function convertEntry(csvEntry) {
-    const xmlEntry = {
-        [input_format_1.nameKey]: csvEntry.token,
-        [input_format_1.attributesKey]: {
-            'line1': csvEntry.line1,
-            'col1': csvEntry.col1,
-            'line2': csvEntry.line2,
-            'col2': csvEntry.col2
-        }
-    };
-    if (csvEntry.text) {
-        xmlEntry[input_format_1.contentKey] = csvEntry.text;
-    }
-    // check and recursively iterate children
-    if (csvEntry.children && csvEntry.children.length > 0) {
-        xmlEntry[input_format_1.childrenKey] = csvEntry.children
-            // we sort children the same way xmlparsedata does (by line, by column, by inverse end line, by inverse end column, by terminal state, by combined "start" tiebreaker value)
-            // (https://github.com/r-lib/xmlparsedata/blob/main/R/package.R#L153C72-L153C78)
-            .sort((c1, c2) => c1.line1 - c2.line1 || c1.col1 - c2.col1 || c2.line2 - c1.line2 || c2.col2 - c1.col2 || Number(c1.terminal) - Number(c2.terminal) || sortTiebreak(c1) - sortTiebreak(c2))
-            .map(convertEntry);
-    }
-    return xmlEntry;
-}
-function sortTiebreak(entry) {
-    // see https://github.com/r-lib/xmlparsedata/blob/main/R/package.R#L110C5-L110C11
-    return entry.line1 * (Math.max(entry.col1, entry.col2) + 1) + entry.col1;
-}
 //# sourceMappingURL=parser.js.map

package/r-bridge/lang-4.x/ast/parser/main/internal/control/normalize-if-then-else.d.ts

@@ -0,0 +1,15 @@
+import type { NormalizerData } from '../../normalizer-data';
+import type { RIfThenElse } from '../../../../model/nodes/r-if-then-else';
+import type { NamedJsonEntry } from '../../../json/format';
+/**
+ * Try to parse the construct as a {@link RIfThenElse}.
+ */
+export declare function tryNormalizeIfThenElse(data: NormalizerData, [ifT, lpT, cT, rpT, tT, eT, ebT]: [
+    ifToken: NamedJsonEntry,
+    leftParen: NamedJsonEntry,
+    condition: NamedJsonEntry,
+    rightParen: NamedJsonEntry,
+    then: NamedJsonEntry,
+    elseToken: NamedJsonEntry,
+    elseBlock: NamedJsonEntry
+]): RIfThenElse | undefined;

package/r-bridge/lang-4.x/ast/parser/{xml → main}/internal/control/normalize-if-then-else.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeIfThenElse = tryNormalizeIfThenElse;
-const parser_1 = require("../../../json/parser");
 const normalize_if_then_1 = require("./normalize-if-then");
 const assert_1 = require("../../../../../../../util/assert");
 const normalize_meta_1 = require("../../normalize-meta");
@@ -10,17 +9,15 @@ const type_1 = require("../../../../model/type");
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
-function tryNormalizeIfThenElse(data, tokens) {
+function tryNormalizeIfThenElse(data, [ifT, lpT, cT, rpT, tT, eT, ebT]) {
     // we start by parsing a regular if-then structure
-    parser_1.parseLog.trace('trying to parse if-then-else structure');
-    const parsedIfThen = (0, normalize_if_then_1.tryNormalizeIfThen)(data, [tokens[0], tokens[1], tokens[2], tokens[3], tokens[4]]);
+    const parsedIfThen = (0, normalize_if_then_1.tryNormalizeIfThen)(data, [ifT, lpT, cT, rpT, tT]);
     if (parsedIfThen === undefined) {
         return undefined;
     }
-    parser_1.parseLog.trace('if-then part successful, now parsing else part');
-    (0, assert_1.guard)(tokens[5].name === type_1.RawRType.Else, () => `expected else token for if-then-else but found ${JSON.stringify(tokens[5])}`);
-    const parsedElse = (0, normalize_single_node_1.normalizeSingleNode)(data, tokens[6]);
-    (0, assert_1.guard)(parsedElse.type !== type_1.RType.Delimiter, () => `unexpected missing else-part of if-then-else, received ${JSON.stringify([parsedIfThen, parsedElse])} for ${JSON.stringify(tokens)}`);
+    (0, assert_1.guard)(eT.name === type_1.RawRType.Else, () => `expected else token for if-then-else but found ${JSON.stringify(eT)}`);
+    const parsedElse = (0, normalize_single_node_1.normalizeSingleNode)(data, ebT);
+    (0, assert_1.guard)(parsedElse.type !== type_1.RType.Delimiter, () => `unexpected missing else-part of if-then-else, received ${JSON.stringify([parsedIfThen, parsedElse])} for ${JSON.stringify([ifT, lpT, cT, rpT, tT, eT, ebT])}`);
     return {
         ...parsedIfThen,
         otherwise: (0, normalize_meta_1.ensureExpressionList)(parsedElse)

package/r-bridge/lang-4.x/ast/parser/{xml → main}/internal/control/normalize-if-then.d.ts

@@ -1,13 +1,13 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { NamedXmlBasedJson } from '../../input-format';
 import type { RIfThenElse } from '../../../../model/nodes/r-if-then-else';
+import type { NamedJsonEntry } from '../../../json/format';
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
-export declare function tryNormalizeIfThen(data: NormalizerData, tokens: [
-    ifToken: NamedXmlBasedJson,
-    leftParen: NamedXmlBasedJson,
-    condition: NamedXmlBasedJson,
-    rightParen: NamedXmlBasedJson,
-    then: NamedXmlBasedJson
+export declare function tryNormalizeIfThen(data: NormalizerData, [ifT, lpT, cT, rpT, tT]: [
+    ifToken: NamedJsonEntry,
+    leftParen: NamedJsonEntry,
+    condition: NamedJsonEntry,
+    rightParen: NamedJsonEntry,
+    then: NamedJsonEntry
 ]): RIfThenElse | undefined;

package/r-bridge/lang-4.x/ast/parser/{xml → main}/internal/control/normalize-if-then.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tryNormalizeIfThen = tryNormalizeIfThen;
-const input_format_1 = require("../../input-format");
+const normalizer_data_1 = require("../../normalizer-data");
 const parser_1 = require("../../../json/parser");
 const normalize_meta_1 = require("../../normalize-meta");
 const type_1 = require("../../../../model/type");
@@ -9,24 +9,23 @@ const normalize_single_node_1 = require("../structure/normalize-single-node");
 /**
  * Try to parse the construct as a {@link RIfThenElse}.
  */
-function tryNormalizeIfThen(data, tokens) {
-    parser_1.parseLog.trace('trying to parse if-then structure');
-    if (tokens[0].name !== type_1.RawRType.If) {
+function tryNormalizeIfThen(data, [ifT, lpT, cT, rpT, tT]) {
+    if (ifT.name !== type_1.RawRType.If) {
         parser_1.parseLog.debug('encountered non-if token for supposed if-then structure');
         return undefined;
     }
-    else if (tokens[1].name !== type_1.RawRType.ParenLeft) {
-        throw new input_format_1.XmlParseError(`expected left-parenthesis for if but found ${JSON.stringify(tokens[1])}`);
+    else if (lpT.name !== type_1.RawRType.ParenLeft) {
+        throw new normalizer_data_1.ParseError(`expected left-parenthesis for if but found ${JSON.stringify(lpT)}`);
     }
-    else if (tokens[3].name !== type_1.RawRType.ParenRight) {
-        throw new input_format_1.XmlParseError(`expected right-parenthesis for if but found ${JSON.stringify(tokens[3])}`);
+    else if (rpT.name !== type_1.RawRType.ParenRight) {
+        throw new normalizer_data_1.ParseError(`expected right-parenthesis for if but found ${JSON.stringify(rpT)}`);
     }
-    const parsedCondition = (0, normalize_single_node_1.normalizeSingleNode)(data, tokens[2]);
-    const parsedThen = (0, normalize_single_node_1.normalizeSingleNode)(data, tokens[4]);
+    const parsedCondition = (0, normalize_single_node_1.normalizeSingleNode)(data, cT);
+    const parsedThen = (0, normalize_single_node_1.normalizeSingleNode)(data, tT);
     if (parsedCondition.type === type_1.RType.Delimiter || parsedThen.type === type_1.RType.Delimiter) {
-        throw new input_format_1.XmlParseError(`unexpected missing parts of if, received ${JSON.stringify([parsedCondition, parsedThen])} for ${JSON.stringify(tokens)}`);
+        throw new normalizer_data_1.ParseError(`unexpected missing parts of if, received ${JSON.stringify([parsedCondition, parsedThen])} for ${JSON.stringify([ifT, lpT, cT, rpT, tT])}`);
     }
-    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(tokens[0].content);
+    const { location, content } = (0, normalize_meta_1.retrieveMetaStructure)(ifT.content);
     return {
         type: type_1.RType.IfThenElse,
         condition: parsedCondition,

package/r-bridge/lang-4.x/ast/parser/{xml → main}/internal/expression/normalize-expression.d.ts

@@ -1,10 +1,10 @@
 import type { NormalizerData } from '../../normalizer-data';
-import type { XmlBasedJson } from '../../input-format';
 import type { RNode } from '../../../../model/model';
+import type { JsonEntry } from '../../../json/format';
 /**
  * Returns an expression list if there are multiple children, otherwise returns the single child directly with no expr wrapper
  *
  * @param data - The data used by the parser (see {@link NormalizerData})
- * @param obj  - The json object to extract the meta-information from
+ * @param entry  - The JSON object to extract the meta-information from
  */
-export declare function normalizeExpression(data: NormalizerData, obj: XmlBasedJson): RNode;
+export declare function normalizeExpression(data: NormalizerData, entry: JsonEntry): RNode;