@eagleoutice/flowr 2.8.5 → 2.8.7

package/documentation/doc-util/doc-types.js

@@ -1,4 +1,37 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,7 +49,7 @@ exports.printCodeOfElement = printCodeOfElement;
 exports.shortLink = shortLink;
 exports.shortLinkFile = shortLinkFile;
 exports.getDocumentationForType = getDocumentationForType;
-const typescript_1 = __importDefault(require("typescript"));
+const typescript_1 = __importStar(require("typescript"));
 const assert_1 = require("../../util/assert");
 const doc_files_1 = require("./doc-files");
 const fs_1 = __importDefault(require("fs"));
@@ -128,6 +161,33 @@ function getStartLineOfTypeScriptNode(node, sourceFile) {
     const lineStart = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line;
     return lineStart + 1;
 }
+function hasModifier(modifiers, modifier) {
+    return modifiers.some(mod => typeof mod === 'object' && mod !== null && 'kind' in mod && mod.kind === modifier);
+}
+function formatNode(node, sourceFile, typeChecker) {
+    const name = node.name?.getText(sourceFile);
+    let prefix = '', suffix = '';
+    if ('modifiers' in node && Array.isArray(node.modifiers)) {
+        if (hasModifier(node.modifiers, typescript_1.SyntaxKind.PrivateKeyword)) {
+            prefix = '-';
+        }
+        else if (hasModifier(node.modifiers, typescript_1.SyntaxKind.ProtectedKeyword)) {
+            prefix = '#';
+        }
+        else if (hasModifier(node.modifiers, typescript_1.SyntaxKind.PublicKeyword)) {
+            prefix = '+';
+        }
+        if (hasModifier(node.modifiers, typescript_1.SyntaxKind.AbstractKeyword)) {
+            suffix = '*';
+        }
+        else if (hasModifier(node.modifiers, typescript_1.SyntaxKind.StaticKeyword)) {
+            suffix = '$';
+        }
+    }
+    const type = getType(node, typeChecker);
+    const typeAnnotation = type.includes('=>') ? type.replaceAll(/\s+=>\s+/g, ' ') : ': ' + type;
+    return `${prefix}${(0, mermaid_1.escapeMarkdown)(name + typeAnnotation)}${suffix}`;
+}
 function getType(node, typeChecker) {
     const tryDirect = typeChecker.getTypeAtLocation(node);
     return tryDirect ? typeChecker.typeToString(tryDirect) : 'unknown';
@@ -168,10 +228,7 @@ function collectHierarchyInformation(sourceFiles, options) {
                 comments: getTextualCommentsFromTypeScript(node),
                 filePath: sourceFile.fileName,
                 lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
-                properties: node.members.map(member => {
-                    const name = member.name?.getText(sourceFile) ?? '';
-                    return `${name}${(0, mermaid_1.escapeMarkdown)(': ' + getType(member, typeChecker))}`;
-                }),
+                properties: node.members.map(member => formatNode(member, sourceFile, typeChecker)),
             });
         }
         else if (typescript_1.default.isTypeAliasDeclaration(node)) {
@@ -209,10 +266,7 @@ function collectHierarchyInformation(sourceFiles, options) {
                 generics: [],
                 filePath: sourceFile.fileName,
                 lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
-                properties: node.members.map(member => {
-                    const name = member.name?.getText(sourceFile) ?? '';
-                    return `${name}${(0, mermaid_1.escapeMarkdown)(': ' + getType(member, typeChecker))}`;
-                })
+                properties: node.members.map(member => formatNode(member, sourceFile, typeChecker))
             });
         }
         else if (typescript_1.default.isEnumMember(node)) {
@@ -244,10 +298,9 @@ function collectHierarchyInformation(sourceFiles, options) {
                 generics,
                 filePath: sourceFile.fileName,
                 lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
-                properties: node.members.map(member => {
-                    const name = member.name?.getText(sourceFile) ?? '';
-                    return `${name}${(0, mermaid_1.escapeMarkdown)(': ' + getType(member, typeChecker))}`;
-                }),
+                properties: node.members
+                    .filter(member => member.name !== undefined)
+                    .map(member => formatNode(member, sourceFile, typeChecker)),
             });
         }
         else if (typescript_1.default.isVariableDeclaration(node) || typescript_1.default.isExportDeclaration(node) || typescript_1.default.isExportAssignment(node) || typescript_1.default.isDeclarationStatement(node)) {
@@ -265,7 +318,7 @@ function collectHierarchyInformation(sourceFiles, options) {
             });
         }
         else if (typescript_1.default.isPropertyAssignment(node) || typescript_1.default.isPropertyDeclaration(node) || typescript_1.default.isPropertySignature(node)
-            || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isMethodSignature(node) || typescript_1.default.isFunctionDeclaration(node)) {
+            || typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isMethodSignature(node) || typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isGetAccessorDeclaration(node) || typescript_1.default.isSetAccessorDeclaration(node)) {
             const name = node.name?.getText(sourceFile) ?? '';
             // get the name of the object/enclosing type
             let parent = node.parent;
@@ -315,22 +368,30 @@ function generateMermaidClassDiagram(hierarchyList, rootName, options, visited =
         return collect;
     }
     const genericPart = node.generics.length > 0 ? `~${node.generics.join(', ')}~` : '';
-    collect.nodeLines.push(`class ${node.name}${genericPart}`);
-    collect.nodeLines.push(`    <<${node.kind}>> ${node.name}`);
-    if (node.kind === 'type') {
-        collect.nodeLines.push(`style ${node.name} opacity:.35,fill:#FAFAFA`);
-    }
+    collect.nodeLines.push(`class ${node.name}${genericPart}{`);
+    collect.nodeLines.push(`    <<${node.kind}>>`);
     const writtenProperties = new Set();
-    if (node.properties) {
+    if (!options.simplify && node.properties) {
         for (const property of node.properties) {
-            collect.nodeLines.push(`    ${node.name} : ${property}`);
+            collect.nodeLines.push(`    ${property}`);
             writtenProperties.add(property);
         }
     }
+    collect.nodeLines.push('}');
+    if (node.kind === 'type') {
+        collect.nodeLines.push(`style ${node.name} opacity:.35,fill:#FAFAFA`);
+    }
     collect.nodeLines.push(`click ${node.name} href "${getTypePathLink(node)}" "${(0, mermaid_1.escapeMarkdown)(node.comments?.join('; ').replace(/\n/g, ' ') ?? '')}"`);
     const inline = [...options.inlineTypes ?? [], ...defaultSkip];
-    if (node.extends.length > 0) {
-        for (const baseType of node.extends) {
+    let baseTypes = node.extends;
+    if (options.reverse) {
+        baseTypes = hierarchyList
+            .filter(e => e.kind === 'class' || e.kind === 'interface' || e.kind === 'type' || e.kind === 'enum')
+            .filter(e => e.extends.includes(rootName))
+            .map(e => e.name);
+    }
+    if (baseTypes.length > 0) {
+        for (const baseType of baseTypes) {
             if (inline.includes(baseType)) {
                 const info = hierarchyList.find(h => h.name === baseType);
                 for (const property of info?.properties ?? []) {
@@ -345,7 +406,7 @@ function generateMermaidClassDiagram(hierarchyList, rootName, options, visited =
                     collect.edgeLines.push(`${dropGenericsFromTypeName(baseType)} .. ${node.name}`);
                 }
                 else {
-                    collect.edgeLines.push(`${dropGenericsFromTypeName(baseType)} <|-- ${node.name}`);
+                    collect.edgeLines.push(`${dropGenericsFromTypeName(baseType)} ${options.reverse ? '--|>' : '<|--'} ${node.name}`);
                 }
                 const { nodeLines, edgeLines } = generateMermaidClassDiagram(hierarchyList, baseType, options, visited);
                 collect.nodeLines.push(...nodeLines);
@@ -364,8 +425,13 @@ function visualizeMermaidClassDiagram(hierarchyList, options) {
     }
     const { nodeLines, edgeLines } = generateMermaidClassDiagram(hierarchyList, options.typeNameForMermaid, options);
     return nodeLines.length === 0 && edgeLines.length === 0 ? '' : `
+---
+  config:
+    class:
+      hideEmptyMembersBox: true
+---
 classDiagram
-direction RL
+direction ${options.reverse ? 'LR' : 'RL'}
 ${nodeLines.join('\n')}
 ${edgeLines.join('\n')}
 `;
@@ -422,12 +488,12 @@ function implSnippet(node, program, showName = true, nesting = 0, open = false,
     const init = showName ? `* ${bold}[${node.name}](${getTypePathLink(node)})${bold} ${sep}${indent}` : '';
     return ` ${indent}${showName ? init : ''} ${text.replaceAll('\t', '    ').split(/\n/g).join(`\n${indent}   `)}`;
 }
-exports.mermaidHide = ['Leaf', 'Location', 'Namespace', 'Base', 'WithChildren', 'Partial', 'RAccessBase'];
+exports.mermaidHide = ['MergeableRecord', 'Leaf', 'Location', 'Namespace', 'Base', 'WithChildren', 'Partial', 'RAccessBase'];
 /**
  * Print the hierarchy of types starting from the given root.
  * If you create a wiki, please refer to the functions provided by the {@link GeneralWikiContext}.
  */
-function printHierarchy({ program, info, root, collapseFromNesting = 1, initialNesting = 0, maxDepth = 20, openTop, showImplSnippet = true }) {
+function printHierarchy({ program, info, root, ignoredTypes, collapseFromNesting = 1, initialNesting = 0, maxDepth = 20, skipNesting = 0, openTop, showImplSnippet = true, reverse = false }) {
     if (initialNesting > maxDepth) {
         return '';
     }
@@ -435,18 +501,29 @@ function printHierarchy({ program, info, root, collapseFromNesting = 1, initialN
     if (!node) {
         return '';
     }
-    const thisLine = implSnippet(node, program, true, initialNesting, initialNesting === 0 && openTop, showImplSnippet);
+    let thisLine = '';
+    if (initialNesting >= skipNesting) {
+        thisLine = implSnippet(node, program, true, initialNesting, initialNesting === 0 && openTop, showImplSnippet);
+    }
+    let baseTypes = node.extends;
+    if (reverse) {
+        baseTypes = info
+            .filter(e => e.kind === 'class' || e.kind === 'interface')
+            .filter(e => e.extends.includes(root))
+            .map(e => e.name);
+    }
     const result = [];
-    for (const baseType of node.extends) {
-        if (exports.mermaidHide.includes(baseType)) {
+    for (const baseType of baseTypes) {
+        if (exports.mermaidHide.includes(baseType) || ignoredTypes?.includes(baseType)) {
             continue;
         }
-        const res = printHierarchy({ program, info: info, root: baseType, collapseFromNesting, initialNesting: initialNesting + 1, maxDepth, showImplSnippet });
+        const res = printHierarchy({ program, info, root: baseType, collapseFromNesting, initialNesting: initialNesting + 1, maxDepth, skipNesting, showImplSnippet, reverse });
         result.push(res);
     }
     const out = result.join('\n');
-    if (initialNesting === collapseFromNesting - 1) {
-        return thisLine + (out ? (0, doc_structure_1.details)(`View more (${node.extends.join(', ')})`, out, { prefixInit: ' '.repeat(2 * (collapseFromNesting + 1)) }) : '');
+    if (initialNesting >= collapseFromNesting - 1) {
+        const more = baseTypes.length > 4 ? baseTypes.slice(0, 4).join(', ') + ', ...' : baseTypes.join(', ');
+        return thisLine + (out ? (0, doc_structure_1.details)(`View more (${more})`, out, { prefixInit: ' '.repeat(2 * (initialNesting + 2)) }) : '');
     }
     else {
         return thisLine + (out ? '\n' + out : '');

package/documentation/wiki-absint.d.ts

@@ -0,0 +1,6 @@
+import type { DocMakerArgs } from './wiki-mk/doc-maker';
+import { DocMaker } from './wiki-mk/doc-maker';
+export declare class WikiAbsint extends DocMaker<'wiki/Abstract Interpretation.md'> {
+    constructor();
+    protected text({ ctx }: DocMakerArgs): Promise<string>;
+}

package/documentation/wiki-absint.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WikiAbsint = void 0;
+const absint_visitor_1 = require("../abstract-interpretation/absint-visitor");
+const abstract_domain_1 = require("../abstract-interpretation/domains/abstract-domain");
+const interval_domain_1 = require("../abstract-interpretation/domains/interval-domain");
+const state_abstract_domain_1 = require("../abstract-interpretation/domains/state-abstract-domain");
+const semantic_cfg_guided_visitor_1 = require("../control-flow/semantic-cfg-guided-visitor");
+const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
+const r_function_call_1 = require("../r-bridge/lang-4.x/ast/model/nodes/r-function-call");
+const doc_code_1 = require("./doc-util/doc-code");
+const doc_structure_1 = require("./doc-util/doc-structure");
+const doc_maker_1 = require("./wiki-mk/doc-maker");
+class IntervalInferenceVisitor extends absint_visitor_1.AbstractInterpretationVisitor {
+    onNumberConstant({ vertex, node }) {
+        super.onNumberConstant({ vertex, node });
+        const interval = new interval_domain_1.IntervalDomain([node.content.num, node.content.num]);
+        this.currentState.set(node.info.id, interval);
+    }
+    onFunctionCall({ call }) {
+        super.onFunctionCall({ call });
+        if (call.args.length === 2 && call.args.every(arg => arg !== r_function_call_1.EmptyArgument)) {
+            const left = this.getAbstractValue(call.args[0].nodeId);
+            const right = this.getAbstractValue(call.args[1].nodeId);
+            if (left === undefined || right === undefined) {
+                // If an operand does not have an inferred interval, this might not be a numerical operation
+                return;
+            }
+            // We map the numerical operation to the resulting interval after applying the abstract semantics of the operation
+            switch (call.name) {
+                case '+':
+                    return this.currentState.set(call.id, left.add(right));
+                case '-':
+                    return this.currentState.set(call.id, left.subtract(right));
+            }
+        }
+    }
+}
+async function inferIntervals() {
+    const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
+        .setEngine('tree-sitter')
+        .build();
+    analyzer.addRequest(`
+		x <- 42
+		y <- if (runif() < 0.5) 6 else 12
+		z <- x + y
+	`.trim());
+    const ast = await analyzer.normalize();
+    const dfg = (await analyzer.dataflow()).graph;
+    const cfg = await analyzer.controlflow();
+    const ctx = analyzer.inspectContext();
+    const domain = new state_abstract_domain_1.StateAbstractDomain(new Map());
+    const inference = new IntervalInferenceVisitor({ controlFlow: cfg, dfg: dfg, normalizedAst: ast, ctx: ctx, domain: domain });
+    inference.start();
+    const result = inference.getEndState();
+    return result.value.entries().toArray()
+        .map(([id, value]) => `${nodeIdToSlicingCriterion(id, ast.idMap)} -> ${value.toString()}`)
+        .join('\n');
+}
+function nodeIdToSlicingCriterion(id, idMap) {
+    const node = idMap.get(id);
+    return `${node?.location?.[0]}@${node?.lexeme}`;
+}
+class WikiAbsint extends doc_maker_1.DocMaker {
+    constructor() {
+        super('wiki/Abstract Interpretation.md', module.filename, 'abstract interpretation framework');
+    }
+    async text({ ctx }) {
+        return `
+This page describes the abstract interpretation framework of _flowR_.
+Abstract interpretation abstracts the concrete semantics of a program to automatically infer properties about the behavior of a program.
+It uses an abstract domain to capture sets of possible runtime values of a program.
+An abstract domain is represented by a lattice with a partial order, join operator (least upper bound), meet operator (greated lower bound), top element (greatest element), and bottom element (least element).
+Abstract interpretation uses an abstraction of the concrete semantics of a program to perform fixpoint iteration to find program invariants.
+
+${(0, doc_structure_1.section)('Abstract Domains', 2, 'abstract-domains')}
+
+To perform abstract interpretation, we first need to define an abstract domain to capture possible runtime values of the program.
+In _flowR_, an abstract domain is represented by the class ${ctx.link(abstract_domain_1.AbstractDomain)} that extends the ${ctx.link('Lattice')} interface. It has the type parameters \`Concrete\` for the concrete domain of the abstract domain (e.g. strings, numbers, lists), \`Abstract\` for the abstract representation of the values (e.g. sets, intervals), \`Top\` for the representation of the top element, \`Bot\` for the representation of the bottom element, and \`Value\` for the type of the current abstract value of the abstract domain (i.e. \`Abstract\`, \`Top\`, or \`Bot\`). An abstract domain provides the following properties and functions:
+
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'value')} the current abstract value of the abstract domain
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'top')} to get the top element (greatest element) of the abstract domain
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'bottom')} to get the bottom element (least element) of the abstract domain
+<!-- --->
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'isTop')} to check whether the current abstract value is top
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'isBottom')} to check whether the current abstract value is bottom
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'isValue')} to check whether the current abstract value is a value (can still be top or bottom)
+<!-- --->
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'leq')} to check whether two abstract values are ordered with respect to the partial order of the lattice
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'join')} to join two abstract values to get the least upper bound (LUB)
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'meet')} to meet two abstract values to get the greates lower bound (GLB)
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'widen')} to perform widening with another abstract value to ensure termination of the fixpoint iteration
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'narrow')} to perform narrowing with another abstract value to refine the abstract value after widening
+<!-- --->
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'concretize')} representing the concretization function of the abstract domain
+ * ${ctx.linkM(abstract_domain_1.AbstractDomain, 'abstract')} representing the abstraction function of the abstract domain
+
+${(0, doc_structure_1.details)('Class Diagram', `
+All boxes link to their respective implementation in the source code.
+${(0, doc_code_1.codeBlock)('mermaid', ctx.mermaid(abstract_domain_1.AbstractDomain))}
+`.trim())}
+
+The ${ctx.link('Top')} and ${ctx.link('Bottom')} symbols can be used to explicitly represent the top or bottom elment of an abstract domain. Additionally, for value abstract domains, there is the ${ctx.link('SatisfiableDomain')} interface that provides the function ${ctx.link('SatisfiableDomain:::satisfies')} to check whether the current abstract value of the abstract domain satisfies a concrete value (see also ${ctx.link('NumericalComparator')} and ${ctx.link('SetComparator')}).
+
+_flowR_ already provides different abstract domains for abstract interpretation in [\`src/abstract-interpretation/domains\`](https://github.com/flowr-analysis/flowr/tree/main/src/abstract-interpretation/domains). Many of the abstract domains are generic and can be used for differend kinds of analyses. The existing abstract domains are presented in the following. Some of the listed abstract domains can be expanded to show the inherited abstract domains.
+
+${ctx.hierarchy(abstract_domain_1.AbstractDomain, { collapseFromNesting: 2, skipNesting: 1, reverse: true })}
+
+${(0, doc_structure_1.details)('Class Diagram', `
+All boxes link to their respective implementation in the source code.
+${(0, doc_code_1.codeBlock)('mermaid', ctx.mermaid(abstract_domain_1.AbstractDomain, { simplify: true, reverse: true }))}
+`.trim())}
+
+${(0, doc_structure_1.section)('Abstract Interpretation', 2, 'abstract-interpretation')}
+
+We perform abstract interpretation by forward-traversing the ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')} of _flowR_ using an ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)}. For each visited control flow vertex, the visitor retrieves the current abstract state by joining the abstract states of the predecessors, applies the abstract semantics of the visited control flow vertex to the current state, and updates the abstract state of the currently visited vertex to the current state. The visitor already handles assignments and (delayed) widening at widening points. However, the visitor does not yet support interprocedural abstract interpretation.
+
+To implement a custom abstract interpretation analysis, we can just create a new class and extend the ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)}. The abstract interpretation visitor uses a ${ctx.link(state_abstract_domain_1.StateAbstractDomain)} to capture the current abstract state at each vertex in the control flow graph. Hence, the abstract interpretation visitor requires a value abstract domain \`Domain\` as type parameter to specify the state abstract domain. We can then extend the callback functions of the ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)} to implement the abstract semantics of expressions, such as ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)}, ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)}, and ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onReplacementCall`)} (make sure to still call the respective super function). The abstract interpretation visitor provides the following functions to retrieve the currently inferred values:
+
+ * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getAbstractValue')} to resolve the inferred abstract value for an AST node (this includes resolving symbols, pipes, and if expressions)
+ * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getAbstractState')} to get the inferred abstract state at an AST node mapping AST nodes to abstract values
+ * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getAbstractTrace')} to get the complete abstract trace mapping AST nodes to abstract states at the respective node
+ * ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState')} to get the inferred abstract state at the end of the program (at the exit points of the control flow graph)
+
+For example, if we want to perform a (very basic) interval analysis using abstract interpretation in _flowR_, we can implement the following ${ctx.link(IntervalInferenceVisitor)} that extends ${ctx.link(absint_visitor_1.AbstractInterpretationVisitor)} using the ${ctx.link(interval_domain_1.IntervalDomain)}:
+
+${ctx.code(IntervalInferenceVisitor)}
+
+The interval inference visitor first overrides the ${ctx.link(`${semantic_cfg_guided_visitor_1.SemanticCfgGuidedVisitor.name}:::onNumberConstant`)} function to infer intervals for visited control flow vertices that represent numeric constants. For numeric constants, the resulting interval consists just of the number value of the constant. We then update the current abstract state of the visitor by setting the inferred abstract value of the currently visited control flow vertex to the new interval.
+
+In this simple example, we only want to support the addition and subtraction of numeric values. Therefore, we override the ${ctx.link(`${absint_visitor_1.AbstractInterpretationVisitor.name}:::onFunctionCall`)} function to apply the abstract semantics of additions and subtraction with resprect to the interval domain. For the addition and subtraction, we are only interested in function calls with exactly two non-empty arguments. We first resolve the currently inferred abstract value for the left and right operand of the function call. If we have no inferred value for one of the operands, this function call might not be a numeric function call and we ignore it. Otherwise, we check whether the function call represents an addition or subtraction and apply the abstract semantics of the operation to the left and right operand. We then again update the current abstract state of the visitor by setting the inferred abstract value of the currently visited function call vertex to the abstract value resulting from applying the abstract semantics of the operation to the operands.
+
+If we now want to run the interval inference, we can write the following code:
+
+${ctx.code(inferIntervals, { dropLinesStart: 1, dropLinesEnd: 5 })}
+
+We first need a ${ctx.linkPage('wiki/Analyzer', 'flowR analyzer')} (in this case, using the ${ctx.linkPage('wiki/Engines', 'tree-sitter engine')}). In this example, we want to analyze a small example code that assigns \`42\` to the variable \`x\`, randomly assigns \`6\` or \`12\` to the variable \`y\`, and assignes the sum of \`x\` and \`y\` to the variable \`z\`. For the abstract interpretation visitor, we need to retrieve the ${ctx.linkPage('wiki/Normalized AST', 'normalized AST')}, ${ctx.linkPage('wiki/Dataflow Graph', 'dataflow graph')}, ${ctx.linkPage('wiki/Control Flow Graph', 'control flow graph')}, and context of the flowR anaylzer. Additionally, we need to provide a state abstract domain for the visitor -- in this case, a state abstract domain for the interval domain. We then construct a new ${ctx.link(IntervalInferenceVisitor)} using the control flow graph, dataflow graph, normalized AST, analyzer context, and state abstract domain, and start the visitor using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'start', { hideClass: true })}. After the visitor is finished, we retrieve the inferred abstract state at the end of the program using ${ctx.linkM(absint_visitor_1.AbstractInterpretationVisitor, 'getEndState', { hideClass: true })}.
+
+If we now print the inferred abstract state at the end of the program, we get the following output:
+
+${(0, doc_code_1.codeBlock)('ts', await inferIntervals())}
+<i>The output has been prettified for better readability.</i>
+
+The AST nodes are represented as slicing criteria for better readability in the format \`<line>@<lexeme>\`. Here, the constants \`42\`, \`0.5\`, \`6\`, and \`12\` of line 1 and 2 are mapped to the intervals \`[42, 42]\`, \`[0.5, 0.5]\`, \`[6, 6]\`, and \`[12, 12]\`, respectively. The variable \`x\` of line 1 is mapped to the interval \`[42, 42]\` of the assigned value and the variable \`y\` of line 2 is assigned to the interval \`[6, 12]\` representing a sound over-approximation of the actual value, as the assigned value can be \`6\` or \`12\`. After applying the abstract semantics of the addition of \`x\` and \`y\`, the addition operation \`+\` and the variable \`z\` of line 3 are mapped to the interval \`[48, 54]\`, resulting from the addition of the interval \`[42, 42]\` of \`x\` and \`[6, 12]\` of \`y\`.
+        `;
+    }
+}
+exports.WikiAbsint = WikiAbsint;
+//# sourceMappingURL=wiki-absint.js.map

package/documentation/wiki-analyzer.js

@@ -112,7 +112,7 @@ The builder provides two methods for building the analyzer:
 
 	For more information on how to configure the builder, please refer to the [Builder Configuration](#builder-configuration) section below.
 
-	${(0, doc_structure_1.section)('Overview of the Analyzer', 3)}
+${(0, doc_structure_1.section)('Overview of the Analyzer', 3)}
 
 Once you have created an analyzer instance, you can add R files, folders, or even entire projects for analysis using the
 ${ctx.linkM(flowr_analyzer_1.FlowrAnalyzer, 'addRequest')} method.

package/documentation/wiki-dataflow-graph.js

@@ -38,6 +38,7 @@ const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
 const flowr_analyzer_context_1 = require("../project/context/flowr-analyzer-context");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
 const flowr_analyzer_1 = require("../project/flowr-analyzer");
+const built_in_1 = require("../dataflow/environments/built-in");
 async function subExplanation(parser, { description, code, expectedSubgraph }) {
     expectedSubgraph = await (0, doc_dfg_1.verifyExpectedSubgraph)(parser, code, expectedSubgraph);
     const marks = [];
@@ -190,9 +191,9 @@ The related function argument references are defined like this:
 ${ctx.hierarchy('FunctionArgument')}
 
 There is another element of potential interest to you, the \`origin\` property which records how flowR created the respective function call.
-These origins may hold the name of any processor that is part of the ${ctx.link('BuiltInProcessorMapper')} to signal that the respective processor was responsible for creating the vertex.
-The entry \`function\` signals that flowR used a processor for a user-defined function defined within the source code, \`unnamed\` signals that the function as an anonymous function definition.
-However, in general, flowR may use any fitting handler as an origin. For example, within a access definition, flowR will correspondingly redefine the meaning of \`:=\` to that of the \`table:assign\`. 
+These origins may hold the name of any processor that is part of the ${ctx.link('BuiltInProcName')} enumeration to signal that the respective processor (cf. ${ctx.link('BuiltInProcessorMapper')}) was responsible for creating the vertex.
+The entry \`${built_in_1.BuiltInProcName.Function}\` signals that flowR used a processor for a user-defined function defined within the source code, \`${built_in_1.BuiltInProcName.Unnamed}\` signals that the function as an anonymous function definition.
+However, in general, flowR may use any fitting handler as an origin (see the ${ctx.link('BuiltInProcName')} enum for a *complete* list). For example, within a access definition, flowR will correspondingly redefine the meaning of \`:=\` to that of the \`${built_in_1.BuiltInProcName.TableAssignment}\`. 
 
 ${(0, doc_structure_1.details)('Example: Simple Function Call (unresolved)', await (async () => {
                 const code = 'foo(x,3,y=3,)';
@@ -362,7 +363,7 @@ ${(0, doc_structure_1.block)({
                 content: `Now you might be asking yourself how to differentiate anonymous and named functions and what you have to keep in mind when working with them?
 
 Unnamed functions have an array of signatures which you can use to identify them. 
-But in short: the \`origin\` attribute of the ${ctx.link('DataflowGraphVertexFunctionCall')} is \`${unnamed_call_handling_1.UnnamedFunctionCallOrigin}\`.
+But in short: the \`origin\` attribute of the ${ctx.link('DataflowGraphVertexFunctionCall')} is \`${built_in_1.BuiltInProcName.Unnamed}\`.
 Please be aware that unnamed functions still have a \`name\` property to give it a unique identifier that can be used for debugging and reference.
 This name _always_ starts with \`${unnamed_call_handling_1.UnnamedFunctionCallPrefix}\`.
 
@@ -499,7 +500,7 @@ Besides this being a theoretically "shorter" way of defining a function, this be
 
 `,
             code: 'function() 1',
-            expectedSubgraph: (0, dataflowgraph_builder_1.emptyGraph)().defineFunction('1@function', [0], { hooks: [], graph: new Set('0'), in: [{ nodeId: 0, controlDependencies: [], type: identifier_1.ReferenceType.Constant, name: undefined }], out: [], unknownReferences: [], entryPoint: 0, environment: (0, environment_builder_1.defaultEnv)() })
+            expectedSubgraph: (0, dataflowgraph_builder_1.emptyGraph)().defineFunction('1@function', [0], { hooks: [], graph: new Set('0'), in: [{ nodeId: 0, cds: [], type: identifier_1.ReferenceType.Constant, name: undefined }], out: [], unknownReferences: [], entryPoint: 0, environment: (0, environment_builder_1.defaultEnv)() })
         }, []]);
     const results = [];
     let i = 0;
@@ -790,7 +791,7 @@ The following vertices types exist:
 
 1. ${(0, doc_data_dfg_util_1.getAllVertices)().map(([k, v], index) => `[\`${k}\`](#${index + 1}-${v.toLowerCase().replace(/\s/g, '-')}-vertex)`).join('\n1. ')}
 
-${(0, doc_structure_1.details)('Class Diagram', 'All boxes should link to their respective implementation:\n' + (0, doc_code_1.codeBlock)('mermaid', ctx.mermaid('DataflowGraphVertexInfo', ['MergeableRecord'])))}
+${(0, doc_structure_1.details)('Class Diagram', 'All boxes should link to their respective implementation:\n' + (0, doc_code_1.codeBlock)('mermaid', ctx.mermaid('DataflowGraphVertexInfo', { inlineTypes: ['MergeableRecord'] })))}
 
 </details>
 
@@ -802,7 +803,7 @@ The following edges types exist, internally we use bitmasks to represent multipl
 
 1. ${(0, doc_data_dfg_util_1.getAllEdges)().map(([k, v], index) => `[\`${k}\` (${v})](#${index + 1}-${k.toLowerCase().replace(/\s/g, '-')}-edge)`).join('\n1. ')}
 
-${(0, doc_structure_1.details)('Class Diagram', 'All boxes should link to their respective implementation:\n' + (0, doc_code_1.codeBlock)('mermaid', ctx.mermaid('EdgeType', ['MergeableRecord'])))}
+${(0, doc_structure_1.details)('Class Diagram', 'All boxes should link to their respective implementation:\n' + (0, doc_code_1.codeBlock)('mermaid', ctx.mermaid('EdgeType', { inlineTypes: ['MergeableRecord'] })))}
 
 </details>
 
@@ -828,7 +829,7 @@ ${(0, doc_general_1.prefixLines)((0, doc_code_1.codeBlock)('ts', `const name = $
 
 ${(0, doc_structure_1.section)('Vertices', 2, 'vertices')}
 
-1. ${(0, doc_data_dfg_util_1.getAllVertices)().map(([k, v]) => `[\`${k}\`](#${v.toLowerCase().replace(/\s/g, '-')}-vertex)`).join('\n1. ')}
+1. ${(0, doc_data_dfg_util_1.getAllVertices)().map(([k, v]) => `[\`${k}\`](#${v.toLowerCase().replaceAll(/\s/g, '-')}-vertex)`).join('\n1. ')}
 
 ${await getVertexExplanations(treeSitter, ctx)}
 
@@ -906,7 +907,7 @@ Let's start by looking at the properties of the dataflow information object: ${O
 
 ${(() => {
                 /* this includes the meta field for timing and the quick CFG in order to enable re-use and improve performance */
-                (0, assert_1.guard)(Object.keys(result).length === 9, () => 'Update Dataflow Documentation!');
+                (0, assert_1.guard)(Object.keys(result).length === 10, () => 'Update Dataflow Documentation! (Keys: ' + Object.keys(result).join(', ') + ')');
                 return '';
             })()}
 
@@ -1043,7 +1044,7 @@ ${await (async () => {
                         return '`' + wanted.types + '`';
                     }
                 }
-                new Error('Could not find edge');
+                throw new Error('Could not find edge');
             })()}&mdash;which is usually not very helpful.
 You can use ${ctx.link(edge_1.splitEdgeTypes.name)} to get the individual bitmasks of all included types, and 
 ${ctx.link(edge_1.edgeIncludesType.name)} to check whether a specific type (or one of a collection of types) is included in the edge.
@@ -1058,7 +1059,7 @@ ${ctx.hierarchy('Origin', { openTop: true })}
 
 Their respective uses are documented alongside their implementation:
 
-${['SimpleOrigin', 'FunctionCallOrigin', 'BuiltInFunctionOrigin'].sort().map(key => `- ${ctx.link(key)}\\\n${ctx.doc(key, { type: 'interface' })}`).join('\n')}
+${['SimpleOrigin', 'FunctionCallOrigin', 'BuiltInFunctionOrigin'].sort((a, b) => a.localeCompare(b)).map(key => `- ${ctx.link(key)}\\\n${ctx.doc(key, { type: 'interface' })}`).join('\n')}
 
 Please note, the current structure of this function is biased by what implementations already exist in flowR.
 Hence, we do not just track definitions and constants, but also the origins of function calls, albeit we do not yet track the origins of values (only resorting to

package/documentation/wiki-interface.js

@@ -21,6 +21,7 @@ const doc_structure_1 = require("./doc-util/doc-structure");
 const tree_sitter_executor_1 = require("../r-bridge/lang-4.x/tree-sitter/tree-sitter-executor");
 const flowr_analyzer_1 = require("../project/flowr-analyzer");
 const doc_maker_1 = require("./wiki-mk/doc-maker");
+const built_in_1 = require("../dataflow/environments/built-in");
 async function explainServer(parser) {
     (0, doc_data_server_messages_1.documentAllServerMessages)();
     return `
@@ -235,7 +236,7 @@ ${(0, doc_code_1.codeBlock)('json', JSON.stringify({
             environment: {
                 overwriteBuiltIns: {
                     definitions: [
-                        { type: 'function', names: ['foo'], processor: 'builtin:assignment', config: {} }
+                        { type: 'function', names: ['foo'], processor: built_in_1.BuiltInProcName.Assignment, config: {} }
                     ]
                 }
             }

package/documentation/wiki-mk/doc-context.d.ts

@@ -1,4 +1,4 @@
-import type { FnElementInfo, PrintHierarchyArguments, TypeElementKind } from '../doc-util/doc-types';
+import type { FnElementInfo, MermaidClassDiagramArguments, PrintHierarchyArguments, TypeElementKind } from '../doc-util/doc-types';
 import type { RShell } from '../../r-bridge/shell';
 import type { ValidWikiDocumentTargetsNoSuffix } from '../../cli/wiki';
 import type { PathLike } from 'fs';
@@ -174,9 +174,9 @@ export interface GeneralDocContext {
     /**
      * Generates a mermaid diagram for the given code element, returned as markdown string.
      * @param element - The element to create a mermaid diagram for, the name can be qualified with `::` to specify the class.
-     * @param inlineTypes - Optional list of type names to inline in the mermaid diagram (instead of linking them out).
+     * @param options - Formatting options for the mermaid class diagram (see {@link MermaidClassDiagramArguments})
      */
-    mermaid(element: ElementIdOrRef, inlineTypes?: string[]): string;
+    mermaid(element: ElementIdOrRef, options?: MermaidClassDiagramArguments): string;
     /**
      * Generates a wiki link to another wiki or general docs page.
      * @example

package/documentation/wiki-mk/doc-context.js

@@ -75,10 +75,10 @@ function makeDocContextForTypes(shell, ...rootFolders) {
             const rVersion = (await shell?.usedRVersion())?.format();
             return (0, doc_auto_gen_1.autoGenHeader)({ filename, purpose, rVersion });
         },
-        mermaid(element, inlineTypes = doc_types_1.mermaidHide) {
+        mermaid(element, options) {
             return (0, doc_types_1.visualizeMermaidClassDiagram)(info, {
                 typeNameForMermaid: getNameFromElementIdOrRef(element),
-                inlineTypes
+                ...options
             });
         },
         linkPage(pageName, linkText, segment) {

package/documentation/wiki-mk/doc-maker.js

@@ -9,9 +9,9 @@ var WikiChangeType;
 })(WikiChangeType || (exports.WikiChangeType = WikiChangeType = {}));
 const DefaultReplacementPatterns = [
     // eslint-disable-next-line no-irregular-whitespace -- we may produce it in output
-    [/[0-9]+(\.[0-9]+)?( |\s*)?ms/g, ''],
+    [/\d+(\.\d+)?( |\s*)?ms/g, ''],
     [/tmp[%A-Za-z0-9-]+/g, ''],
-    [/"?(timing|searchTimeMs|processTimeMs|id|treeSitterId)"?:\s*[0-9]+(\.[0-9])?,?/g, ''],
+    [/"?(timing|searchTimeMs|processTimeMs|id|treeSitterId)"?:\s*\d+(\.\d)?,?/g, ''],
     [/"format":"compact".+/gmius, ''],
     [/%%\s*\d*-+/g, ''],
     [/"[rR]": "\d+\.\d+\.\d+.*?"/g, ''],

package/documentation/wiki-normalized-ast.d.ts

@@ -1,5 +1,14 @@
+import { DefaultNormalizedAstFold } from '../abstract-interpretation/normalized-ast-fold';
 import type { DocMakerArgs } from './wiki-mk/doc-maker';
 import { DocMaker } from './wiki-mk/doc-maker';
+import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RBinaryOp } from '../r-bridge/lang-4.x/ast/model/nodes/r-binary-op';
+export declare class MyMathFold<Info> extends DefaultNormalizedAstFold<number, Info> {
+    constructor();
+    protected concat(a: number, b: number): number;
+    foldRNumber(node: RNumber<Info>): number;
+    foldRBinaryOp(node: RBinaryOp<Info>): number;
+}
 /**
  * https://github.com/flowr-analysis/flowr/wiki/Normalized-AST
  */