@eagleoutice/flowr 1.3.11

package/slicing/criterion/parse.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertAllSlicingCriteriaToIds = exports.slicingCriterionToId = exports.CriteriaParseError = void 0;
+const static_1 = require("../static");
+/**
+ * Thrown if the given slicing criteria can not be found
+ */
+class CriteriaParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CriteriaParseError';
+    }
+}
+exports.CriteriaParseError = CriteriaParseError;
+/**
+ * Takes a criterion in the form of `line:column` or `line@variable-name` and returns the corresponding node id
+ */
+function slicingCriterionToId(criterion, decorated) {
+    let resolved;
+    if (criterion.includes(':')) {
+        const [line, column] = criterion.split(':').map(c => parseInt(c));
+        resolved = locationToId({ line, column }, decorated.idMap);
+    }
+    else if (criterion.includes('@')) {
+        const [line, name] = criterion.split(/@(.*)/s); // only split at first occurrence
+        resolved = conventionalCriteriaToId(parseInt(line), name, decorated.idMap);
+    }
+    else if (criterion.startsWith('$')) {
+        resolved = criterion.substring(1);
+    }
+    if (resolved === undefined) {
+        throw new CriteriaParseError(`invalid slicing criterion ${criterion}`);
+    }
+    return resolved;
+}
+exports.slicingCriterionToId = slicingCriterionToId;
+function locationToId(location, dataflowIdMap) {
+    let candidate;
+    for (const [id, nodeInfo] of dataflowIdMap.entries()) {
+        if (nodeInfo.location === undefined || nodeInfo.location.start.line !== location.line || nodeInfo.location.start.column !== location.column) {
+            continue; // only consider those with position information
+        }
+        static_1.slicerLogger.trace(`can resolve id ${id} (${JSON.stringify(nodeInfo.location)}) for location ${JSON.stringify(location)}`);
+        // function calls have the same location as the symbol they refer to, so we need to prefer the function call
+        if (candidate !== undefined && nodeInfo.type !== "RFunctionCall" /* RType.FunctionCall */ && nodeInfo.type !== "RArgument" /* RType.Argument */ || nodeInfo.type === "RExpressionList" /* RType.ExpressionList */) {
+            continue;
+        }
+        candidate = nodeInfo;
+    }
+    const id = candidate?.info.id;
+    if (id) {
+        static_1.slicerLogger.trace(`resolve id ${id} (${JSON.stringify(candidate?.info)}) for location ${JSON.stringify(location)}`);
+    }
+    return id;
+}
+function conventionalCriteriaToId(line, name, dataflowIdMap) {
+    let candidate;
+    for (const [id, nodeInfo] of dataflowIdMap.entries()) {
+        if (nodeInfo.location === undefined || nodeInfo.location.start.line !== line || nodeInfo.lexeme !== name) {
+            continue;
+        }
+        static_1.slicerLogger.trace(`can resolve id ${id} (${JSON.stringify(nodeInfo)}) for line ${line} and name ${name}`);
+        // function calls have the same location as the symbol they refer to, so we need to prefer the function call
+        if (candidate !== undefined && nodeInfo.type !== "RFunctionCall" /* RType.FunctionCall */ && nodeInfo.type !== "RArgument" /* RType.Argument */ || nodeInfo.type === "RExpressionList" /* RType.ExpressionList */) {
+            continue;
+        }
+        candidate = nodeInfo;
+    }
+    const id = candidate?.info.id;
+    if (id) {
+        static_1.slicerLogger.trace(`resolve id ${id} (${JSON.stringify(candidate?.info)}) for line ${line} and name ${name}`);
+    }
+    return id;
+}
+function convertAllSlicingCriteriaToIds(criteria, decorated) {
+    return criteria.map(l => ({ criterion: l, id: slicingCriterionToId(l, decorated) }));
+}
+exports.convertAllSlicingCriteriaToIds = convertAllSlicingCriteriaToIds;
+//# sourceMappingURL=parse.js.map

package/slicing/index.d.ts

@@ -0,0 +1,3 @@
+export * from './static';
+export * from './criterion';
+export * from '../reconstruct/reconstruct';

package/slicing/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./static"), exports);
+__exportStar(require("./criterion"), exports);
+__exportStar(require("../reconstruct/reconstruct"), exports);
+//# sourceMappingURL=index.js.map

package/slicing/static/index.d.ts

@@ -0,0 +1 @@
+export * from './static-slicer';

package/slicing/static/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./static-slicer"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,29 @@
+import { DataflowGraph } from '../../dataflow';
+import { NodeId, NormalizedAst } from '../../r-bridge';
+import { DecodedCriteria, SlicingCriteria } from '../criterion';
+export declare const slicerLogger: import("tslog").Logger<import("tslog").ILogObj>;
+/**
+ * The result of the slice step
+ */
+export interface SliceResult {
+    /**
+     * Number of times the set threshold was hit (i.e., the same node was visited too often).
+     * While any number above 0 might indicate a wrong slice, it does not have to as usually even revisiting the same node does not
+     * often cause more ids to be included in the slice.
+     */
+    timesHitThreshold: number;
+    /**
+     * The ids of the nodes in the normalized ast that are part of the slice.
+     */
+    result: Set<NodeId>;
+    /**
+     * The mapping produced to decode the entered criteria
+     */
+    decodedCriteria: DecodedCriteria;
+}
+/**
+ * This returns the ids to include in the slice, when slicing with the given seed id's (must be at least one).
+ * <p>
+ * The returned ids can be used to {@link reconstructToCode | reconstruct the slice to R code}.
+ */
+export declare function staticSlicing(dataflowGraph: DataflowGraph, ast: NormalizedAst, criteria: SlicingCriteria, threshold?: number): Readonly<SliceResult>;

package/slicing/static/static-slicer.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.staticSlicing = exports.slicerLogger = void 0;
+const dataflow_1 = require("../../dataflow");
+const assert_1 = require("../../util/assert");
+const r_bridge_1 = require("../../r-bridge");
+const log_1 = require("../../util/log");
+const linker_1 = require("../../dataflow/internal/linker");
+const environments_1 = require("../../dataflow/environments");
+const object_hash_1 = __importDefault(require("object-hash"));
+const defaultmap_1 = require("../../util/defaultmap");
+const scopes_1 = require("../../dataflow/environments/scopes");
+const criterion_1 = require("../criterion");
+exports.slicerLogger = log_1.log.getSubLogger({ name: 'slicer' });
+function envFingerprint(env) {
+    return (0, object_hash_1.default)(env, { excludeKeys: key => key === 'id' });
+}
+function fingerprint(id, envFingerprint, onlyForSideEffects) {
+    return `${id}-${envFingerprint}-${onlyForSideEffects ? '0' : '1'}`;
+}
+class VisitingQueue {
+    threshold;
+    timesHitThreshold = 0;
+    seen = new Map();
+    idThreshold = new defaultmap_1.DefaultMap(() => 0);
+    queue = [];
+    constructor(threshold) {
+        this.threshold = threshold;
+    }
+    add(target, env, envFingerprint, onlyForSideEffects) {
+        const idCounter = this.idThreshold.get(target);
+        if (idCounter > this.threshold) {
+            exports.slicerLogger.warn(`id: ${target} has been visited ${idCounter} times, skipping`);
+            this.timesHitThreshold++;
+            return;
+        }
+        else {
+            this.idThreshold.set(target, idCounter + 1);
+        }
+        const print = fingerprint(target, envFingerprint, onlyForSideEffects);
+        if (!this.seen.has(print)) {
+            this.seen.set(print, target);
+            this.queue.push({ id: target, baseEnvironment: env, onlyForSideEffects: onlyForSideEffects });
+        }
+    }
+    next() {
+        return this.queue.pop();
+    }
+    has() {
+        return this.queue.length > 0;
+    }
+    status() {
+        return {
+            timesHitThreshold: this.timesHitThreshold,
+            result: new Set(this.seen.values())
+        };
+    }
+}
+/**
+ * This returns the ids to include in the slice, when slicing with the given seed id's (must be at least one).
+ * <p>
+ * The returned ids can be used to {@link reconstructToCode | reconstruct the slice to R code}.
+ */
+function staticSlicing(dataflowGraph, ast, criteria, threshold = 75) {
+    (0, assert_1.guard)(criteria.length > 0, 'must have at least one seed id to calculate slice');
+    const decodedCriteria = (0, criterion_1.convertAllSlicingCriteriaToIds)(criteria, ast);
+    const idMap = ast.idMap;
+    if (exports.slicerLogger.settings.minLevel <= 1 /* LogLevel.Trace */) {
+        exports.slicerLogger.trace(`calculating slice for ${decodedCriteria.length} seed criteria: ${decodedCriteria.map(s => JSON.stringify(s)).join(', ')}`);
+    }
+    const queue = new VisitingQueue(threshold);
+    // every node ships the call environment which registers the calling environment
+    {
+        const basePrint = envFingerprint((0, dataflow_1.initializeCleanEnvironments)());
+        for (const startId of decodedCriteria) {
+            queue.add(startId.id, (0, dataflow_1.initializeCleanEnvironments)(), basePrint, false);
+        }
+    }
+    while (queue.has()) {
+        const current = queue.next();
+        if (current === undefined) {
+            continue;
+        }
+        const baseEnvFingerprint = envFingerprint(current.baseEnvironment);
+        const currentInfo = dataflowGraph.get(current.id, true);
+        // slicerLogger.trace(`visiting id: ${current.id} with name: ${currentInfo?.[0].name ?? '<unknown>'}`)
+        if (currentInfo === undefined) {
+            exports.slicerLogger.warn(`id: ${current.id} must be in graph but can not be found, keep in slice to be sure`);
+            continue;
+        }
+        if (currentInfo[0].tag === 'function-call' && !current.onlyForSideEffects) {
+            exports.slicerLogger.trace(`${current.id} is a function call`);
+            sliceForCall(current, idMap, currentInfo[0], dataflowGraph, queue);
+        }
+        const currentNode = idMap.get(current.id);
+        (0, assert_1.guard)(currentNode !== undefined, () => `id: ${current.id} must be in dataflowIdMap is not in ${(0, dataflow_1.graphToMermaidUrl)(dataflowGraph, idMap)}`);
+        for (const [target, edge] of currentInfo[1]) {
+            if (edge.types.has(dataflow_1.EdgeType.SideEffectOnCall)) {
+                queue.add(target, current.baseEnvironment, baseEnvFingerprint, true);
+            }
+            if (edge.types.has(dataflow_1.EdgeType.Reads) || edge.types.has(dataflow_1.EdgeType.DefinedBy) || edge.types.has(dataflow_1.EdgeType.Argument) || edge.types.has(dataflow_1.EdgeType.Calls) || edge.types.has(dataflow_1.EdgeType.Relates) || edge.types.has(dataflow_1.EdgeType.DefinesOnCall)) {
+                queue.add(target, current.baseEnvironment, baseEnvFingerprint, false);
+            }
+        }
+        for (const controlFlowDependency of addControlDependencies(currentInfo[0].id, idMap)) {
+            queue.add(controlFlowDependency, current.baseEnvironment, baseEnvFingerprint, false);
+        }
+    }
+    // slicerLogger.trace(`static slicing produced: ${JSON.stringify([...seen])}`)
+    return { ...queue.status(), decodedCriteria };
+}
+exports.staticSlicing = staticSlicing;
+function addAllFrom(current, collected) {
+    for (const id of (0, r_bridge_1.collectAllIds)(current)) {
+        collected.add(id);
+    }
+}
+function addControlDependencies(source, ast) {
+    const start = ast.get(source);
+    const collected = new Set();
+    let current = start;
+    while (current !== undefined) {
+        if (current.type === "RIfThenElse" /* RType.IfThenElse */) {
+            addAllFrom(current.condition, collected);
+        }
+        else if (current.type === "RWhileLoop" /* RType.WhileLoop */) {
+            addAllFrom(current.condition, collected);
+        }
+        else if (current.type === "RForLoop" /* RType.ForLoop */) {
+            addAllFrom(current.variable, collected);
+            // vector not needed, if required, it is  linked by defined-by
+        }
+        // nothing to do for repeat and rest!
+        current = current.info.parent ? ast.get(current.info.parent) : undefined;
+    }
+    return collected;
+}
+function retrieveActiveEnvironment(callerInfo, baseEnvironment) {
+    let callerEnvironment = callerInfo.environment;
+    if (baseEnvironment.level !== callerEnvironment.level) {
+        while (baseEnvironment.level < callerEnvironment.level) {
+            baseEnvironment = (0, environments_1.pushLocalEnvironment)(baseEnvironment);
+        }
+        while (baseEnvironment.level > callerEnvironment.level) {
+            callerEnvironment = (0, environments_1.pushLocalEnvironment)(callerEnvironment);
+        }
+    }
+    return (0, environments_1.overwriteEnvironments)(baseEnvironment, callerEnvironment);
+}
+//// returns the new threshold hit count
+function sliceForCall(current, idMap, callerInfo, dataflowGraph, queue) {
+    // bind with call-local environments during slicing
+    const outgoingEdges = dataflowGraph.get(callerInfo.id, true);
+    (0, assert_1.guard)(outgoingEdges !== undefined, () => `outgoing edges of id: ${callerInfo.id} must be in graph but can not be found, keep in slice to be sure`);
+    // lift baseEnv on the same level
+    const baseEnvironment = current.baseEnvironment;
+    const baseEnvPrint = envFingerprint(baseEnvironment);
+    const activeEnvironment = retrieveActiveEnvironment(callerInfo, baseEnvironment);
+    const activeEnvironmentFingerprint = envFingerprint(activeEnvironment);
+    const functionCallDefs = (0, environments_1.resolveByName)(callerInfo.name, scopes_1.LocalScope, activeEnvironment)?.map(d => d.nodeId) ?? [];
+    for (const [target, outgoingEdge] of outgoingEdges[1].entries()) {
+        if (outgoingEdge.types.has(dataflow_1.EdgeType.Calls)) {
+            functionCallDefs.push(target);
+        }
+    }
+    const functionCallTargets = (0, linker_1.getAllLinkedFunctionDefinitions)(new Set(functionCallDefs), dataflowGraph);
+    for (const [_, functionCallTarget] of functionCallTargets) {
+        // all those linked within the scopes of other functions are already linked when exiting a function definition
+        for (const openIn of functionCallTarget.subflow.in) {
+            const defs = (0, environments_1.resolveByName)(openIn.name, scopes_1.LocalScope, activeEnvironment);
+            if (defs === undefined) {
+                continue;
+            }
+            for (const def of defs) {
+                queue.add(def.nodeId, baseEnvironment, baseEnvPrint, current.onlyForSideEffects);
+            }
+        }
+        for (const exitPoint of functionCallTarget.exitPoints) {
+            queue.add(exitPoint, activeEnvironment, activeEnvironmentFingerprint, current.onlyForSideEffects);
+        }
+    }
+}
+//# sourceMappingURL=static-slicer.js.map

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

@@ -0,0 +1,30 @@
+/**
+ * Defines the type of syntax constructs that we track (e.g., true, false, 0, 1, T, F, conditions...)
+ */
+import { RFalse, RNodeWithParent, RTrue } from '../../r-bridge';
+import { SummarizedMeasurement } from '../../util/summarizer/benchmark/data';
+export interface CommonSyntaxTypeCounts<Measurement = bigint> {
+    total: Measurement;
+    multiple: Measurement;
+    empty: Measurement;
+    withArgument: Measurement;
+    noValue: Measurement;
+    singleVar: Record<string, Measurement>;
+    number: Record<number, Measurement>;
+    integer: Record<number, Measurement>;
+    complex: Record<number, Measurement>;
+    string: Record<string, Measurement>;
+    logical: Record<typeof RTrue | typeof RFalse, Measurement>;
+    call: Record<string, Measurement>;
+    unnamedCall: Measurement;
+    binOp: Record<string, Measurement>;
+    unaryOp: Record<string, Measurement>;
+    other: Record<string, Measurement>;
+}
+export declare function emptyCommonSyntaxTypeCounts<T = bigint>(init?: () => T): CommonSyntaxTypeCounts<T>;
+/**
+ * Updates the given counts based on the type of the given node.
+ */
+export declare function updateCommonSyntaxTypeCounts(current: CommonSyntaxTypeCounts, ...nodes: RNodeWithParent[]): CommonSyntaxTypeCounts;
+export declare function appendCommonSyntaxTypeCounter(a: CommonSyntaxTypeCounts<number[][]>, b: CommonSyntaxTypeCounts): void;
+export declare function summarizeCommonSyntaxTypeCounter(a: CommonSyntaxTypeCounts<number[][]>): CommonSyntaxTypeCounts<SummarizedMeasurement>;

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeCommonSyntaxTypeCounter = exports.appendCommonSyntaxTypeCounter = exports.updateCommonSyntaxTypeCounts = exports.emptyCommonSyntaxTypeCounts = void 0;
+/**
+ * Defines the type of syntax constructs that we track (e.g., true, false, 0, 1, T, F, conditions...)
+ */
+const r_bridge_1 = require("../../r-bridge");
+const process_1 = require("../../util/summarizer/benchmark/first-phase/process");
+const numbers_1 = require("../../util/numbers");
+function emptyCommonSyntaxTypeCounts(init = () => 0n) {
+    return {
+        total: init(),
+        multiple: init(),
+        empty: init(),
+        withArgument: init(),
+        noValue: init(),
+        singleVar: {},
+        number: {},
+        integer: {},
+        complex: {},
+        string: {},
+        logical: {},
+        call: {},
+        unnamedCall: init(),
+        binOp: {},
+        unaryOp: {},
+        other: {}
+    };
+}
+exports.emptyCommonSyntaxTypeCounts = emptyCommonSyntaxTypeCounts;
+function incrementEntry(map, key) {
+    map[key] = (map[key] ?? 0n) + 1n;
+}
+/**
+ * Updates the given counts based on the type of the given node.
+ */
+function updateCommonSyntaxTypeCounts(current, ...nodes) {
+    current.total++;
+    if (nodes.length === 0) {
+        current.empty++;
+        return current;
+    }
+    else if (nodes.length > 1) {
+        current.multiple++;
+        return current;
+    }
+    let node = nodes[0];
+    if (node.type === "RArgument" /* RType.Argument */) {
+        if (node.name !== undefined) {
+            current.withArgument++;
+        }
+        if (node.value !== undefined) {
+            node = node.value;
+        }
+        else {
+            current.noValue++;
+            return current;
+        }
+    }
+    switch (node.type) {
+        case "RString" /* RType.String */:
+            incrementEntry(current.string, node.content.str);
+            break;
+        case "RSymbol" /* RType.Symbol */:
+            incrementEntry(current.singleVar, node.content);
+            break;
+        case "RLogical" /* RType.Logical */:
+            incrementEntry(current.logical, node.content ? r_bridge_1.RTrue : r_bridge_1.RFalse);
+            break;
+        case "RNumber" /* RType.Number */:
+            if (node.content.complexNumber) {
+                incrementEntry(current.complex, node.content.num);
+            }
+            else if (node.content.markedAsInt) {
+                incrementEntry(current.integer, node.content.num);
+            }
+            else {
+                incrementEntry(current.number, node.content.num);
+            }
+            break;
+        case "RFunctionCall" /* RType.FunctionCall */:
+            if (node.flavor === 'unnamed') {
+                current.unnamedCall++;
+            }
+            else {
+                incrementEntry(current.call, node.functionName.content);
+            }
+            break;
+        case "RBinaryOp" /* RType.BinaryOp */:
+            incrementEntry(current.binOp, node.operator);
+            break;
+        case "RUnaryOp" /* RType.UnaryOp */:
+            incrementEntry(current.unaryOp, node.operator);
+            break;
+        default:
+            // for space reasons we do not record the full lexeme!
+            if (node.lexeme) {
+                incrementEntry(current.other, node.lexeme);
+            }
+            break;
+    }
+    return current;
+}
+exports.updateCommonSyntaxTypeCounts = updateCommonSyntaxTypeCounts;
+function appendRecord(a, b) {
+    for (const [key, val] of Object.entries(b)) {
+        const get = a[key];
+        // we guard with array to guard against methods like `toString` which are given in js
+        if (!get || !Array.isArray(get)) {
+            a[key] = [[(0, numbers_1.bigint2number)(val)]];
+            continue;
+        }
+        get.push([(0, numbers_1.bigint2number)(val)]);
+    }
+}
+function appendCommonSyntaxTypeCounter(a, b) {
+    a.total.push([(0, numbers_1.bigint2number)(b.total)]);
+    a.empty.push([(0, numbers_1.bigint2number)(b.empty)]);
+    a.multiple.push([(0, numbers_1.bigint2number)(b.multiple)]);
+    a.withArgument.push([(0, numbers_1.bigint2number)(b.withArgument)]);
+    a.noValue.push([(0, numbers_1.bigint2number)(b.noValue)]);
+    a.unnamedCall.push([(0, numbers_1.bigint2number)(b.unnamedCall)]);
+    appendRecord(a.singleVar, b.singleVar);
+    appendRecord(a.number, b.number);
+    appendRecord(a.integer, b.integer);
+    appendRecord(a.complex, b.complex);
+    appendRecord(a.string, b.string);
+    appendRecord(a.logical, b.logical);
+    appendRecord(a.call, b.call);
+    appendRecord(a.binOp, b.binOp);
+    appendRecord(a.unaryOp, b.unaryOp);
+    appendRecord(a.other, b.other);
+}
+exports.appendCommonSyntaxTypeCounter = appendCommonSyntaxTypeCounter;
+function summarizeRecord(a) {
+    return Object.fromEntries(Object.entries(a).map(([key, val]) => [key, (0, process_1.summarizeMeasurement)(val.flat(), val.length)]));
+}
+function summarizeCommonSyntaxTypeCounter(a) {
+    return {
+        total: (0, process_1.summarizeMeasurement)(a.total.flat(), a.total.length),
+        empty: (0, process_1.summarizeMeasurement)(a.empty.flat(), a.empty.length),
+        multiple: (0, process_1.summarizeMeasurement)(a.multiple.flat(), a.multiple.length),
+        withArgument: (0, process_1.summarizeMeasurement)(a.withArgument.flat(), a.withArgument.length),
+        noValue: (0, process_1.summarizeMeasurement)(a.noValue.flat(), a.noValue.length),
+        unnamedCall: (0, process_1.summarizeMeasurement)(a.unnamedCall.flat(), a.unnamedCall.length),
+        singleVar: summarizeRecord(a.singleVar),
+        number: summarizeRecord(a.number),
+        integer: summarizeRecord(a.integer),
+        complex: summarizeRecord(a.complex),
+        string: summarizeRecord(a.string),
+        logical: summarizeRecord(a.logical),
+        call: summarizeRecord(a.call),
+        binOp: summarizeRecord(a.binOp),
+        unaryOp: summarizeRecord(a.unaryOp),
+        other: summarizeRecord(a.other)
+    };
+}
+exports.summarizeCommonSyntaxTypeCounter = summarizeCommonSyntaxTypeCounter;
+//# sourceMappingURL=common-syntax-probability.js.map