@eagleoutice/flowr 2.9.0 → 2.9.2

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-dispatch.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S7DispatchSeparator = void 0;
+exports.processS7Dispatch = processS7Dispatch;
+const known_call_handling_1 = require("../known-call-handling");
+const built_in_1 = require("../../../../../environments/built-in");
+const identifier_1 = require("../../../../../environments/identifier");
+/** Used to separate S7 dispatch info in identifiers */
+exports.S7DispatchSeparator = '﹕s3﹕';
+/**
+ * Process an S7 generic dispatch call like `S7_dispatch`.
+ */
+function processS7Dispatch(name, args, rootId, data) {
+    if (!('currentS7name' in data) || !Array.isArray(data.currentS7name)) {
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: built_in_1.BuiltInProcName.S7Dispatch }).information;
+    }
+    const info = (0, known_call_handling_1.processKnownFunctionCall)({ name, forceArgs: 'all', args, rootId, data, origin: built_in_1.BuiltInProcName.S7Dispatch }).information;
+    for (const id of data.currentS7name) {
+        if (typeof id === 'string') {
+            const newIn = info.in.slice();
+            newIn.push({ nodeId: rootId, name: id, cds: data.cds, type: identifier_1.ReferenceType.S7MethodPrefix });
+            info.in = newIn;
+        }
+    }
+    return info;
+}
+//# sourceMappingURL=built-in-s-seven-dispatch.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-new-generic.d.ts

@@ -0,0 +1,19 @@
+import type { DataflowProcessorInformation } from '../../../../../processor';
+import type { DataflowInformation } from '../../../../../info';
+import type { ParentInformation } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { type RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import type { NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+/** e.g. new_generic(name, dispatch_args, fun=NULL) */
+interface S7GenericDispatchConfig {
+    args: {
+        name: string;
+        dispatchArg: string | undefined;
+        fun: string;
+    };
+}
+/**
+ * Process an S7 new generic dispatch call like `new_generic` or `setGeneric`.
+ */
+export declare function processS7NewGeneric<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>, config: S7GenericDispatchConfig): DataflowInformation;
+export {};

package/dataflow/internal/process/functions/call/built-in/built-in-s-seven-new-generic.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processS7NewGeneric = processS7NewGeneric;
+const known_call_handling_1 = require("../known-call-handling");
+const logger_1 = require("../../../../../logger");
+const linker_1 = require("../../../../linker");
+const common_1 = require("../common");
+const unpack_argument_1 = require("../argument/unpack-argument");
+const r_argument_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-argument");
+const built_in_1 = require("../../../../../environments/built-in");
+const edge_1 = require("../../../../../graph/edge");
+const type_1 = require("../../../../../../r-bridge/lang-4.x/ast/model/type");
+const range_1 = require("../../../../../../util/range");
+const assert_1 = require("../../../../../../util/assert");
+const identifier_1 = require("../../../../../environments/identifier");
+const alias_tracking_1 = require("../../../../../eval/resolve/alias-tracking");
+const r_value_1 = require("../../../../../eval/values/r-value");
+const vertex_1 = require("../../../../../graph/vertex");
+/**
+ * Process an S7 new generic dispatch call like `new_generic` or `setGeneric`.
+ */
+function processS7NewGeneric(name, args, rootId, data, config) {
+    if (args.length < 1) {
+        logger_1.dataflowLogger.warn('empty s7 new_generic, skipping');
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
+    }
+    const params = {
+        [config.args.name]: 'name',
+    };
+    if (config.args.dispatchArg) {
+        params[config.args.dispatchArg] = 'dispatchArg';
+    }
+    params[config.args.fun] = 'fun';
+    params['...'] = '...';
+    const argMaps = (0, linker_1.invertArgumentMap)((0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params));
+    const genName = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('name')?.[0]));
+    if (!genName) {
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
+    }
+    const n = (0, alias_tracking_1.resolveIdToValue)(genName.info.id, { environment: data.environment, resolve: data.ctx.config.solver.variables, idMap: data.completeAst.idMap, full: true, ctx: data.ctx });
+    const accessedIdentifiers = [];
+    if (n.type === 'set') {
+        for (const elem of n.elements) {
+            if (elem.type === 'string' && (0, r_value_1.isValue)(elem.value)) {
+                accessedIdentifiers.push(elem.value.str);
+            }
+        }
+    }
+    if (accessedIdentifiers.length === 0) {
+        logger_1.dataflowLogger.warn('s7 new_generic non-resolvable skipping');
+        return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
+    }
+    data = { ...data, currentS7name: accessedIdentifiers };
+    let funArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('fun')?.[0]))?.info.id;
+    const effectiveArgs = args.slice();
+    if (!funArg) {
+        const dispatchArg = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('dispatchArg')?.[0]));
+        const newFun = makeS7DispatchFDef(name, [dispatchArg?.lexeme ?? undefined], rootId, args.length, data.completeAst.idMap);
+        // fake it 'function([dispatch_args],...) S7_dispatch()'
+        effectiveArgs.push(newFun[0]);
+        funArg = newFun[1];
+    }
+    const info = (0, known_call_handling_1.processKnownFunctionCall)({ name, forceArgs: 'all', args: effectiveArgs, rootId, data, origin: built_in_1.BuiltInProcName.S7NewGeneric }).information;
+    info.graph.addEdge(rootId, funArg, edge_1.EdgeType.Returns);
+    info.entryPoint = funArg;
+    const fArg = info.graph.getVertex(funArg);
+    if (fArg?.tag === vertex_1.VertexType.FunctionDefinition) {
+        fArg.mode ??= ['s4', 's7'];
+    }
+    return info;
+}
+// 'function([dispatch_args],...) S7_dispatch()'; returns the value id
+function makeS7DispatchFDef(name, names, rootId, args, idMap) {
+    const argNameId = rootId + '-s7-new-generic-fun-arg-name';
+    const r = name.location ?? (0, range_1.invalidRange)();
+    const argName = {
+        type: type_1.RType.Symbol,
+        lexeme: 'fun',
+        content: 'fun',
+        info: {
+            id: argNameId,
+            nesting: name.info.nesting,
+            role: "arg-name" /* RoleInParent.ArgumentName */,
+            fullRange: r,
+            adToks: undefined,
+            file: name.info.file,
+            parent: rootId,
+            index: 0
+        },
+        location: r,
+    };
+    idMap.set(argNameId, argName);
+    const funcNameId = rootId + '-s7-new-generic-fun-name';
+    const funcName = {
+        type: type_1.RType.Symbol,
+        lexeme: 'S7_dispatch',
+        info: {
+            id: funcNameId,
+            nesting: name.info.nesting,
+            role: "call-name" /* RoleInParent.FunctionCallName */,
+            fullRange: r,
+            adToks: undefined,
+            file: name.info.file,
+            parent: rootId,
+            index: 0
+        },
+        location: r,
+        content: identifier_1.Identifier.make('S7_dispatch', 's7'),
+    };
+    const funcBody = {
+        type: type_1.RType.FunctionCall,
+        location: r,
+        lexeme: 'S7_dispatch',
+        named: true,
+        functionName: funcName,
+        arguments: [],
+        info: {
+            id: rootId + '-s7-new-generic-fun-body',
+            nesting: name.info.nesting,
+            role: "fun-body" /* RoleInParent.FunctionDefinitionBody */,
+            fullRange: r,
+            adToks: undefined,
+            file: name.info.file,
+            parent: rootId,
+            index: 0
+        }
+    };
+    const fdefId = rootId + '-s7-new-generic-fun-fdef';
+    const argValue = {
+        type: type_1.RType.FunctionDefinition,
+        info: {
+            file: name.info.file,
+            id: fdefId,
+            nesting: name.info.nesting,
+            role: "arg-value" /* RoleInParent.ArgumentValue */,
+            parent: rootId,
+            index: args + 1,
+            adToks: undefined,
+            fullRange: r,
+        },
+        lexeme: 'function',
+        location: r,
+        parameters: [...names.filter(assert_1.isNotUndefined), '...'].map((n, i) => {
+            const paramId = fdefId + `-param-${i}`;
+            const paramNameId = paramId + '-name';
+            const paramName = {
+                type: type_1.RType.Symbol,
+                lexeme: n,
+                content: n,
+                info: {
+                    id: paramNameId,
+                    nesting: name.info.nesting,
+                    role: "param-name" /* RoleInParent.ParameterName */,
+                    fullRange: r,
+                    adToks: undefined,
+                    file: name.info.file,
+                    index: i,
+                    parent: paramId
+                },
+                location: r,
+            };
+            const param = {
+                type: type_1.RType.Parameter,
+                location: r,
+                lexeme: n,
+                name: paramName,
+                defaultValue: undefined,
+                special: n === '...',
+                info: {
+                    id: paramId,
+                    nesting: name.info.nesting,
+                    role: "param" /* RoleInParent.FunctionDefinitionParameter */,
+                    parent: fdefId,
+                    index: i,
+                    adToks: undefined,
+                    file: name.info.file,
+                    fullRange: r,
+                }
+            };
+            idMap.set(paramNameId, paramName);
+            idMap.set(paramId, param);
+            return param;
+        }),
+        body: funcBody,
+    };
+    idMap.set(funcNameId, funcName);
+    idMap.set(funcBody.info.id, funcBody);
+    idMap.set(fdefId, argValue);
+    const argId = rootId + '-s7-new-generic-fun-arg';
+    const argument = {
+        type: type_1.RType.Argument,
+        lexeme: 'fun',
+        location: r,
+        info: {
+            id: argId,
+            nesting: name.info.nesting,
+            role: "call-arg" /* RoleInParent.FunctionCallArgument */,
+            fullRange: r,
+            adToks: undefined,
+            file: name.info.file,
+            parent: rootId,
+            index: args + 1
+        },
+        name: argName,
+        value: argValue
+    };
+    idMap.set(argument.info.id, argument);
+    return [argument, argValue.info.id];
+}
+//# sourceMappingURL=built-in-s-seven-new-generic.js.map

package/dataflow/internal/process/functions/call/built-in/built-in-s-three-dispatch.d.ts

@@ -10,6 +10,8 @@ interface S3DispatchConfig {
         generic: string;
         object: string;
     };
+    /** For NextMethod/if `generic` is not given, try to infer from the closure? */
+    inferFromClosure?: boolean;
 }
 /**
  * Process an S3 dispatch call like `UseMethod`.

package/dataflow/internal/process/functions/call/built-in/built-in-s-three-dispatch.js

@@ -19,7 +19,7 @@ const range_1 = require("../../../../../../util/range");
  * Process an S3 dispatch call like `UseMethod`.
  */
 function processS3Dispatch(name, args, rootId, data, config) {
-    if (args.length === 0) {
+    if (args.length === 0 && !config.inferFromClosure) {
         logger_1.dataflowLogger.warn('empty s3, skipping');
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
@@ -30,7 +30,7 @@ function processS3Dispatch(name, args, rootId, data, config) {
     };
     const argMaps = (0, linker_1.invertArgumentMap)((0, linker_1.pMatch)((0, common_1.convertFnArguments)(args), params));
     const generic = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('generic')?.[0]));
-    if (!generic) {
+    if (!generic && !config.inferFromClosure) {
         return (0, known_call_handling_1.processKnownFunctionCall)({ name, args, rootId, data, origin: 'default' }).information;
     }
     const obj = (0, unpack_argument_1.unpackArg)((0, r_argument_1.getArgumentWithId)(args, argMaps.get('object')?.[0]));
@@ -46,6 +46,28 @@ function processS3Dispatch(name, args, rootId, data, config) {
         });
         return dfObj;
     }
+    if (!generic) {
+        (0, common_1.patchFunctionCall)({
+            nextGraph: dfObj.graph,
+            rootId,
+            name,
+            data,
+            argumentProcessResult: [dfObj],
+            origin: built_in_1.BuiltInProcName.S3DispatchNext
+        });
+        const ingoing = dfObj.in.concat(dfObj.unknownReferences);
+        ingoing.push({ nodeId: rootId, name: name.content, cds: data.cds, type: identifier_1.ReferenceType.Function });
+        return {
+            hooks: dfObj.hooks,
+            environment: dfObj.environment,
+            exitPoints: dfObj.exitPoints,
+            graph: dfObj.graph,
+            entryPoint: rootId,
+            in: ingoing,
+            out: dfObj.out,
+            unknownReferences: []
+        };
+    }
     const n = (0, alias_tracking_1.resolveIdToValue)(generic.info.id, { environment: data.environment, resolve: data.ctx.config.solver.variables, idMap: data.completeAst.idMap, full: true, ctx: data.ctx });
     const accessedIdentifiers = [];
     if (n.type === 'set') {

package/dataflow/internal/process/functions/call/named-call-handling.d.ts

@@ -11,5 +11,6 @@ import type { DataflowGraph } from '../../../../graph/graph';
 export declare function markAsOnlyBuiltIn(graph: DataflowGraph, rootId: NodeId): void;
 /**
  * Processes a named function call within the dataflow analysis.
+ * For example, `myFunction(arg1, arg2)`, resolves against the environment.
  */
 export declare function processNamedCall<OtherInfo>(name: RSymbol<OtherInfo & ParentInformation>, args: readonly RFunctionArgument<OtherInfo & ParentInformation>[], rootId: NodeId, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/named-call-handling.js

@@ -41,6 +41,7 @@ function markAsOnlyBuiltIn(graph, rootId) {
 }
 /**
  * Processes a named function call within the dataflow analysis.
+ * For example, `myFunction(arg1, arg2)`, resolves against the environment.
  */
 function processNamedCall(name, args, rootId, data) {
     const resolved = (0, resolve_by_name_1.resolveByName)(name.content, data.environment, identifier_1.ReferenceType.Function) ?? [];

package/dataflow/internal/process/functions/call/unnamed-call-handling.d.ts

@@ -5,5 +5,6 @@ import type { ParentInformation } from '../../../../../r-bridge/lang-4.x/ast/mod
 export declare const UnnamedFunctionCallPrefix = "unnamed-fc-";
 /**
  * Processes an unnamed function call.
+ * For example `(function(x) { x + 1 })(5)`
  */
 export declare function processUnnamedFunctionCall<OtherInfo>(functionCall: RUnnamedFunctionCall<OtherInfo & ParentInformation>, data: DataflowProcessorInformation<OtherInfo & ParentInformation>): DataflowInformation;

package/dataflow/internal/process/functions/call/unnamed-call-handling.js

@@ -15,6 +15,7 @@ const built_in_1 = require("../../../../environments/built-in");
 exports.UnnamedFunctionCallPrefix = 'unnamed-fc-';
 /**
  * Processes an unnamed function call.
+ * For example `(function(x) { x + 1 })(5)`
  */
 function processUnnamedFunctionCall(functionCall, data) {
     const calledFunction = (0, processor_1.processDataflowFor)(functionCall.calledFunction, data);

package/documentation/data/interface/doc-writing-code.js

@@ -4,7 +4,6 @@ exports.explainWritingCode = explainWritingCode;
 const shell_1 = require("../../../r-bridge/shell");
 const flowr_analyzer_1 = require("../../../project/flowr-analyzer");
 const doc_code_1 = require("../../doc-util/doc-code");
-const doc_files_1 = require("../../doc-util/doc-files");
 const pipeline_executor_1 = require("../../../core/pipeline-executor");
 const retriever_1 = require("../../../r-bridge/retriever");
 const doc_structure_1 = require("../../doc-util/doc-structure");
@@ -77,7 +76,7 @@ See the in-code documentation for more information.
 ### Using the ${ctx.link(shell_1.RShell)} to Interact with R
 
 The ${ctx.link(shell_1.RShell)} class allows interfacing with the \`R\` ecosystem installed on the host system.
-Please have a look at [flowR's engines](${doc_files_1.FlowrWikiBaseRef}/Engines) for more information on alterantives (for example, the ${ctx.link(tree_sitter_executor_1.TreeSitterExecutor)}).
+Please have a look at ${ctx.linkPage('wiki/Engines', 'flowR\'s Engines')} for more information on alternatives (for example, the ${ctx.link(tree_sitter_executor_1.TreeSitterExecutor)}).
 
 ${(0, doc_structure_1.block)({
         type: 'IMPORTANT',

package/documentation/wiki-dataflow-graph.js

@@ -1004,13 +1004,17 @@ Depending on what you are interested in, there exists a plethora of functions an
 * ${ctx.link(node_id_1.recoverName)} and ${ctx.link(node_id_1.recoverContent)} to get the name or content of a vertex in the dataflow graph
 * ${ctx.link(alias_tracking_1.resolveIdToValue)} to resolve the value of a variable or id (if possible, see [below](#dfg-resolving-values))
 * ${ctx.link(alias_tracking_1.getAliases)} to get all (potentially currently) aliases of a given definition
-* ${ctx.link('DfEdge', undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
-* ${ctx.link('Identifier', undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
 * ${ctx.link(identify_link_to_last_call_relation_1.getValueOfArgument)} to get the (syntactical) value of an argument in a function call 
 * ${ctx.link(dfg_get_origin_1.getOriginInDfg)} to get information about where a read, call, ... comes from (see [below](#dfg-resolving-values))
 
-Some of these functions have been explained in their respective wiki pages. However, some are part of the [Dataflow Graph API](${doc_files_1.FlowrWikiBaseRef}/Dataflow-Graph) and so we explain them here.
-If you are interested in which features we support and which features are still to be worked on, please refer to our [capabilities](${doc_files_1.FlowrWikiBaseRef}/Capabilities) page.
+FlowR also provides various helper objects (with the same name as the corresponding type) to help you work with the dataflow graph:
+
+* ${ctx.link('DfEdge', undefined, { type: 'variable' })} to get helpful functions wrt. edges (see [below](#dfg-resolving-values))
+* ${ctx.link('Identifier', undefined, { type: 'variable' })} to get helpful functions wrt. identifiers
+* ${ctx.link('FunctionArgument', undefined, { type: 'variable' })} to get helpful functions wrt. function arguments
+
+Some of these functions have been explained in their respective wiki pages. However, some are part of the ${ctx.linkPage('wiki/Dataflow Graph', 'Dataflow Graph API')} and so we explain them here.
+If you are interested in which features we support and which features are still to be worked on, please refer to our ${ctx.linkPage('wiki/Capabilities', 'capabilities')} page.
 
 ${(0, doc_structure_1.section)('Resolving Values', 3, 'dfg-resolving-values')}
 

package/linter/rules/naming-convention.d.ts

@@ -26,6 +26,8 @@ export interface NamingConventionConfig extends MergeableRecord {
     caseing: CasingConvention | 'auto';
     /** if true non alphabetic characters are ignored */
     ignoreNonAlpha: boolean;
+    /** optional prefix to ignore on all identifiers, which is interpreted as a regular expression fragment (meaning special characters have to be escaped) */
+    ignorePrefix?: string;
 }
 export interface NamingConventionMetadata extends MergeableRecord {
     /** number of symbols matching the casing convetion */
@@ -34,9 +36,14 @@ export interface NamingConventionMetadata extends MergeableRecord {
     numBreak: number;
 }
 /**
- * Attempts to detect the casing convention used in the given identifier.
+ * Attempts to detect the possible casing conventions used in the given identifier and returns an array ordered by likelihood of the casing convention being correct.
  */
-export declare function detectCasing(identifier: string): CasingConvention;
+export declare function detectPotentialCasings(identifier: string, ignorePrefix?: string): CasingConvention[];
+/**
+ * Attempts to detect the possible casing conventions used in the given identifier and returns the first result.
+ * The function {@link detectPotentialCasings} is generally preferred, as it returns all potential casings and not just the first one.
+ */
+export declare function detectCasing(identifier: string, ignorePrefix?: string): CasingConvention;
 /**
  * Determines the most used casing convention in the given list of symbols.
  */

package/linter/rules/naming-convention.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NAMING_CONVENTION = exports.CasingConvention = void 0;
+exports.detectPotentialCasings = detectPotentialCasings;
 exports.detectCasing = detectCasing;
 exports.getMostUsedCasing = getMostUsedCasing;
 exports.fixCasing = fixCasing;
@@ -26,50 +27,51 @@ function containsAlpha(s) {
     return /[A-Za-z]/.test(s);
 }
 /**
- * Attempts to detect the casing convention used in the given identifier.
+ * Attempts to detect the possible casing conventions used in the given identifier and returns an array ordered by likelihood of the casing convention being correct.
  */
-function detectCasing(identifier) {
+function detectPotentialCasings(identifier, ignorePrefix) {
     if (identifier.trim() === '' || !containsAlpha(identifier)) {
-        return CasingConvention.Unknown;
+        return [];
+    }
+    if (ignorePrefix) {
+        identifier = identifier.replace(new RegExp(`^(${ignorePrefix})`), '');
     }
     const upper = identifier.toUpperCase();
     const lower = identifier.toLowerCase();
     const isAllUpper = identifier === upper;
     const isAllLower = identifier === lower;
-    if (identifier.includes('_')) {
-        if (isAllUpper) { // CONSTANT_CASE
-            return CasingConvention.ConstantCase;
-        }
-        else if (isAllLower) { // snake_case
-            return CasingConvention.SnakeCase;
-        }
-        // Returns true if the letter after an _ is uppercase
-        function expectUpperAfterScore(identifier) {
-            for (let i = 0; i < identifier.length - 1; i++) {
-                if (identifier[i] === '_') {
-                    if (identifier[i + 1] !== upper[i + 1]) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
-        if (identifier[0] === lower[0] && expectUpperAfterScore(identifier)) { // camel_Snake_Case
-            return CasingConvention.CamelSnakeCase;
-        }
-        else if (identifier[0] === upper[0] && expectUpperAfterScore(identifier)) { // Pascal_Snake_Case
-            return CasingConvention.PascalSnakeCase;
-        }
+    const hasUnderscores = identifier.includes('_');
+    const upperAfterAllScores = Array(identifier.length - 1).keys().every(i => identifier[i] !== '_' || identifier[i + 1] === upper[i + 1]);
+    const hasAnyUpperAfterLower = Array(identifier.length - 1).keys().some(i => containsAlpha(identifier[i]) && identifier[i] === lower[i] &&
+        containsAlpha(identifier[i + 1]) && identifier[i + 1] === upper[i + 1]);
+    const matches = [];
+    if (!hasUnderscores && identifier[0] === lower[0]) {
+        matches.push(CasingConvention.CamelCase); // camelCase
     }
-    else {
-        if (identifier[0] === lower[0]) { // camelCase
-            return CasingConvention.CamelCase;
-        }
-        else if (identifier[0] === upper[0]) { // PascalCase
-            return CasingConvention.PascalCase;
-        }
+    if (!hasUnderscores && identifier[0] === upper[0] && (identifier.length === 1 || !isAllUpper)) {
+        matches.push(CasingConvention.PascalCase); // PascalCase or Pascalcase
+    }
+    if (isAllUpper) {
+        matches.push(CasingConvention.ConstantCase); // CONSTANT_CASE or CONSTANTCASE
+    }
+    if (isAllLower) {
+        matches.push(CasingConvention.SnakeCase); // snake_case or snakecase or snakecase_
+    }
+    if (upperAfterAllScores && identifier[0] === lower[0] && !isAllUpper && hasUnderscores || (!hasUnderscores && isAllLower)) {
+        matches.push(CasingConvention.CamelSnakeCase); // camel_Snake_Case or camelsnakecase or camelsnakecase_
     }
-    return CasingConvention.Unknown;
+    if (upperAfterAllScores && identifier[0] === upper[0] && (identifier.length === 1 || !isAllUpper) && !hasAnyUpperAfterLower) {
+        matches.push(CasingConvention.PascalSnakeCase); // Pascal_Snake_Case or Pascalsnakecase
+    }
+    return matches;
+}
+/**
+ * Attempts to detect the possible casing conventions used in the given identifier and returns the first result.
+ * The function {@link detectPotentialCasings} is generally preferred, as it returns all potential casings and not just the first one.
+ */
+function detectCasing(identifier, ignorePrefix) {
+    const casings = detectPotentialCasings(identifier, ignorePrefix);
+    return casings.length > 0 ? casings[0] : CasingConvention.Unknown;
 }
 /**
  * Determines the most used casing convention in the given list of symbols.
@@ -156,7 +158,7 @@ exports.NAMING_CONVENTION = {
         const symbols = elements.getElements()
             .map(m => ({
             certainty: linter_format_1.LintingResultCertainty.Certain,
-            detectedCasing: detectCasing(m.node.lexeme),
+            detectedCasing: detectCasing(m.node.lexeme, config.ignorePrefix),
             name: m.node.lexeme,
             range: m.node.info.fullRange,
             id: m.node.info.id

package/linter/rules/seeded-randomness.js

@@ -86,7 +86,7 @@ exports.SEEDED_RANDOMNESS = {
                 // assignments have to be queried for their destination
                 for (const a of assignment ?? []) {
                     const argIdx = assignmentArgIndexes.get(identifier_1.Identifier.getName(a.name));
-                    const dest = (0, graph_1.getReferenceOfArgument)(a.args[argIdx]);
+                    const dest = graph_1.FunctionArgument.getReference(a.args[argIdx]);
                     if (dest !== undefined && assignmentProducers.has((0, node_id_1.recoverName)(dest, dataflow.graph.idMap))) {
                         // we either have arg index 0 or 1 for the assignmentProducers destination, so we select the assignment value as 1-argIdx here
                         if (isConstantArgument(dataflow.graph, a, 1 - argIdx, analyzer.inspectContext())) {
@@ -143,7 +143,7 @@ function getDefaultAssignments() {
     return default_builtin_config_1.DefaultBuiltinConfig.filter(b => b.type === 'function' && (b.processor === built_in_1.BuiltInProcName.Assignment || b.processor === built_in_1.BuiltInProcName.AssignmentLike));
 }
 function isConstantArgument(graph, call, argIndex, ctx) {
-    const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.getReferenceOfArgument);
+    const args = call.args.filter(arg => arg !== r_function_call_1.EmptyArgument && !arg.name).map(graph_1.FunctionArgument.getReference);
     const values = (0, general_1.valueSetGuard)((0, alias_tracking_1.resolveIdToValue)(args[argIndex], { graph: graph, resolve: config_1.VariableResolve.Alias, ctx }));
     return values?.elements.every(v => v.type === 'number' ||
         v.type === 'logical' ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eagleoutice/flowr",
-  "version": "2.9.0",
+  "version": "2.9.2",
   "description": "Static Dataflow Analyzer and Program Slicer for the R Programming Language",
   "types": "dist/src/index.d.ts",
   "repository": {
@@ -43,6 +43,7 @@
     "test:full": "npm run test-full",
     "test-full": "npm run test:coverage -- --no-watch -- --make-summary --test-installation",
     "performance-test": "func() { cd test/performance/ && bash run-all-suites.sh $1 $2 $3 $4; cd ../../; }; func",
+    "test:performance": "npm run performance-test --",
     "detect-circular-deps": "npx madge  --extensions ts,tsx --circular src/",
     "checkup": "npm run flowr -- --execute \":version\" && npm run lint && npm run test-full -- --allowOnly=false && npm run test:system -- --no-watch && docker build -t test-flowr -f scripts/Dockerfile . && npm run doc && npm run gen:readme && npm-run-all wiki:*"
   },

package/project/plugins/file-plugins/files/flowr-namespace-file.d.ts

@@ -2,6 +2,7 @@ import type { FileRole, FlowrFileProvider } from '../../../context/flowr-file';
 import { FlowrFile } from '../../../context/flowr-file';
 import type { RNode } from '../../../../r-bridge/lang-4.x/ast/model/model';
 import type { FlowrAnalyzerContext } from '../../../context/flowr-analyzer-context';
+import type { ParentInformation } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 export interface NamespaceInfo {
     exportedSymbols: string[];
     exportedFunctions: string[];
@@ -13,7 +14,7 @@ export interface NamespaceInfo {
      * This will only be present in complex parsed NAMESPACE files and tell you
      * about which parts are only active with given conditions!
      */
-    conditional?: Map<RNode, NamespaceInfo>;
+    conditional?: Map<RNode<ParentInformation>, NamespaceInfo>;
 }
 export interface NamespaceFormat {
     current: NamespaceInfo;
@@ -37,6 +38,13 @@ export declare class FlowrNamespaceFile extends FlowrFile<NamespaceFormat> {
      * @see {@link parseNamespaceComplex} for a more complex parser.
      */
     protected loadContent(): NamespaceFormat;
+    /**
+     * Either returns whether the given symbol/function is exported from the given package
+     * or the list of (`and`) conditions under which it is exported.
+     * @param name - The name of the symbol/function to check
+     * @param pkg - The package to check in
+     */
+    isExported(name: string, pkg?: string): boolean | RNode<ParentInformation>[];
     /**
      * Namespace file lifter, this does not re-create if already a namespace file
      * and handles role assignments.
@@ -46,3 +54,18 @@ export declare class FlowrNamespaceFile extends FlowrFile<NamespaceFormat> {
      */
     static from(file: FlowrFileProvider | FlowrNamespaceFile, ctx?: FlowrAnalyzerContext, role?: FileRole): FlowrNamespaceFile;
 }
+/**
+ * Either returns whether the given symbol/function is exported from the given package
+ * or the list of (`and`) conditions under which it is exported.
+ * @param fmt  - The namespace format to check in
+ * @param name - The name of the symbol/function to check
+ * @param pkg  - The package to check in
+ */
+export declare function isExportedInNamespaceFormat(this: void, fmt: NamespaceFormat, name: string, pkg?: string): boolean | RNode<ParentInformation>[];
+/**
+ * Either returns whether the given symbol/function is exported from the given namespace info,
+ * or the list of (`and`) conditions under which it is exported.
+ * @param name   - The name of the symbol/function to check
+ * @param nsInfo - The namespace info to check in
+ */
+export declare function isExportedInInfo(this: void, name: string, nsInfo: NamespaceInfo): boolean | RNode<ParentInformation>[];