@eagleoutice/flowr 2.0.25 → 2.1.0

package/dataflow/environments/default-builtin-config.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultBuiltinConfig = void 0;
+/**
+ * Contains the built-in definitions recognized by flowR
+ */
+exports.DefaultBuiltinConfig = [
+    { type: 'constant', names: ['NULL', 'NA'], value: null, assumePrimitive: true },
+    { type: 'constant', names: ['TRUE', 'T'], value: true, assumePrimitive: true },
+    { type: 'constant', names: ['FALSE', 'F'], value: false, assumePrimitive: true },
+    {
+        type: 'function',
+        names: [
+            '~', '+', '-', '*', '/', '^', '!', '?', '**', '==', '!=', '>', '<', '>=', '<=', '%%', '%/%', '%*%', '%in%', ':', 'list', 'c',
+            'rep', 'seq', 'seq_len', 'seq_along', 'seq.int', 'gsub', 'which', 'class', 'dimnames', 'min', 'max',
+            'intersect', 'subset', 'match', 'sqrt', 'abs', 'round', 'floor', 'ceiling', 'signif', 'trunc', 'log', 'log10', 'log2', 'sum', 'mean',
+            'unique', 'paste', 'paste0', 'read.csv', 'stop', 'is.null', 'plot', 'numeric', 'as.character', 'as.integer', 'as.logical', 'as.numeric', 'as.matrix',
+            'rbind', 'nrow', 'ncol', 'tryCatch', 'expression', 'factor',
+            'missing', 'as.data.frame', 'data.frame', 'na.omit', 'rownames', 'names', 'order', 'length', 'any', 'dim', 'matrix', 'cbind', 'nchar', 't'
+        ],
+        processor: 'builtin:default',
+        config: { readAllArguments: true },
+        assumePrimitive: false
+    },
+    { type: 'function', names: ['options'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: 'all' }, assumePrimitive: false },
+    { type: 'function', names: ['mapply', 'Mapply'], processor: 'builtin:apply', config: { indexOfFunction: 0, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
+    { type: 'function', names: ['lapply', 'sapply', 'vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
+    { type: 'function', names: ['Lapply', 'Sapply', 'Vapply'], processor: 'builtin:apply', config: { indexOfFunction: 1, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false }, /* functool wrappers */
+    { type: 'function', names: ['apply', 'tapply', 'Tapply'], processor: 'builtin:apply', config: { indexOfFunction: 2, nameOfFunctionArgument: 'FUN' }, assumePrimitive: false },
+    { type: 'function', names: ['print'], processor: 'builtin:default', config: { returnsNthArgument: 0, forceArgs: 'all' }, assumePrimitive: false },
+    { type: 'function', names: ['('], processor: 'builtin:default', config: { returnsNthArgument: 0 }, assumePrimitive: true },
+    { type: 'function', names: ['load', 'load_all', 'setwd', 'set.seed'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
+    { type: 'function', names: ['eval', 'body', 'formals', 'environment'], processor: 'builtin:default', config: { hasUnknownSideEffects: true, forceArgs: [true] }, assumePrimitive: false },
+    { type: 'function', names: ['cat'], processor: 'builtin:default', config: { forceArgs: 'all' }, assumePrimitive: false },
+    { type: 'function', names: ['switch'], processor: 'builtin:default', config: { forceArgs: [true] }, assumePrimitive: false },
+    { type: 'function', names: ['return'], processor: 'builtin:default', config: { returnsNthArgument: 0, cfg: 1 /* ExitPointType.Return */ }, assumePrimitive: false },
+    { type: 'function', names: ['break'], processor: 'builtin:default', config: { cfg: 2 /* ExitPointType.Break */ }, assumePrimitive: false },
+    { type: 'function', names: ['next'], processor: 'builtin:default', config: { cfg: 3 /* ExitPointType.Next */ }, assumePrimitive: false },
+    { type: 'function', names: ['{'], processor: 'builtin:expression-list', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['source'], processor: 'builtin:source', config: { includeFunctionCall: true, forceFollow: false }, assumePrimitive: false },
+    { type: 'function', names: ['[', '[['], processor: 'builtin:access', config: { treatIndicesAsString: false }, assumePrimitive: true },
+    { type: 'function', names: ['$', '@'], processor: 'builtin:access', config: { treatIndicesAsString: true }, assumePrimitive: true },
+    { type: 'function', names: ['if', 'ifelse'], processor: 'builtin:if-then-else', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['get'], processor: 'builtin:get', config: {}, assumePrimitive: false },
+    { type: 'function', names: ['library', 'require'], processor: 'builtin:library', config: {}, assumePrimitive: false },
+    { type: 'function', names: ['<-', '='], processor: 'builtin:assignment', config: { canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: [':=', 'assign'], processor: 'builtin:assignment', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['delayedAssign'], processor: 'builtin:assignment', config: { quoteSource: true }, assumePrimitive: true },
+    { type: 'function', names: ['<<-'], processor: 'builtin:assignment', config: { superAssignment: true, canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: ['->'], processor: 'builtin:assignment', config: { swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: ['->>'], processor: 'builtin:assignment', config: { superAssignment: true, swapSourceAndTarget: true, canBeReplacement: true }, assumePrimitive: true },
+    { type: 'function', names: ['&&', '&'], processor: 'builtin:special-bin-op', config: { lazy: true, evalRhsWhen: true }, assumePrimitive: true },
+    { type: 'function', names: ['||', '|'], processor: 'builtin:special-bin-op', config: { lazy: true, evalRhsWhen: false }, assumePrimitive: true },
+    { type: 'function', names: ['|>', '%>%'], processor: 'builtin:pipe', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['function', '\\'], processor: 'builtin:function-definition', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['quote', 'substitute', 'bquote'], processor: 'builtin:quote', config: { quoteArgumentsWithIndex: 0 }, assumePrimitive: true },
+    { type: 'function', names: ['for'], processor: 'builtin:for-loop', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['repeat'], processor: 'builtin:repeat-loop', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['while'], processor: 'builtin:while-loop', config: {}, assumePrimitive: true },
+    { type: 'function', names: ['do.call'], processor: 'builtin:apply', config: { indexOfFunction: 0, unquoteFunction: true }, assumePrimitive: true },
+    {
+        type: 'function',
+        names: [
+            'on.exit', 'sys.on.exit', 'par', 'setnames', 'setNames', 'setkey', 'setkeyv', 'setindex', 'setindexv', 'setattr', 'sink',
+            /* library and require is handled above */
+            'requireNamespace', 'loadNamespace', 'attachNamespace', 'asNamespace',
+            /* downloader and installer functions (R, devtools, BiocManager) */
+            'library.dynam', 'install.packages', 'install', 'install_github', 'install_gitlab', 'install_bitbucket', 'install_url', 'install_git', 'install_svn', 'install_local', 'install_version', 'update_packages',
+            /* weird env attachments */
+            'attach', 'detach', 'unname', 'rm', 'remove'
+        ],
+        processor: 'builtin:default',
+        config: { hasUnknownSideEffects: true },
+        assumePrimitive: false
+    },
+    /* they are all mapped to `<-` but we separate super assignments */
+    {
+        type: 'replacement',
+        suffixes: ['<-', '<<-'],
+        names: ['[', '[[', '$', '@', 'names', 'dimnames', 'attributes', 'attr', 'class', 'levels', 'rownames', 'colnames', 'body', 'environment', 'formals']
+    }
+];
+//# sourceMappingURL=default-builtin-config.js.map

package/dataflow/environments/define.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.define = void 0;
+exports.define = define;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 const clone_1 = require("./clone");
@@ -47,5 +47,4 @@ function define(definition, superAssign, environment) {
     }
     return newEnvironment;
 }
-exports.define = define;
 //# sourceMappingURL=define.js.map

package/dataflow/environments/diff.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.diffEnvironmentInformation = exports.diffEnvironment = exports.diffIdentifierReferences = void 0;
+exports.diffIdentifierReferences = diffIdentifierReferences;
+exports.diffEnvironment = diffEnvironment;
+exports.diffEnvironmentInformation = diffEnvironmentInformation;
 const diff_1 = require("../../util/diff");
 const environment_1 = require("./environment");
 const json_1 = require("../../util/json");
@@ -21,7 +23,6 @@ function diffIdentifierReferences(a, b, info) {
     }
     (0, info_1.diffControlDependencies)(a.controlDependencies, b.controlDependencies, info);
 }
-exports.diffIdentifierReferences = diffIdentifierReferences;
 function diffMemory(a, b, info) {
     for (const [key, value] of a.memory) {
         const value2 = b.memory.get(key);
@@ -45,8 +46,8 @@ function diffMemory(a, b, info) {
             if (aVal.definedAt !== bVal.definedAt) {
                 info.report.addComment(`${info.position}Different definition ids (definedAt) for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.definedAt} vs. ${info.rightname}: ${bVal.definedAt}`);
             }
-            if (aVal.kind !== bVal.kind) {
-                info.report.addComment(`${info.position}Different kinds for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.kind} vs. ${info.rightname}: ${bVal.kind}`);
+            if (aVal.type !== bVal.type) {
+                info.report.addComment(`${info.position}Different types for ${key} (${aVal.nodeId}). ${info.leftname}: ${aVal.type} vs. ${info.rightname}: ${bVal.type}`);
             }
         }
     }
@@ -72,7 +73,6 @@ function diffEnvironment(a, b, info, depth) {
     diffMemory(a, b, { ...info, position: `${info.position}[at level: ${depth}] ` });
     diffEnvironment(a.parent, b.parent, { ...info, position: `${info.position}Parents of ${a.id} & ${b.id}. ` }, depth--);
 }
-exports.diffEnvironment = diffEnvironment;
 function diffEnvironmentInformation(a, b, info) {
     if (a === undefined || b === undefined) {
         if (a !== b) {
@@ -85,5 +85,4 @@ function diffEnvironmentInformation(a, b, info) {
     }
     diffEnvironment(a.current, b.current, info, Math.max(a.level, b.level));
 }
-exports.diffEnvironmentInformation = diffEnvironmentInformation;
 //# sourceMappingURL=diff.js.map

package/dataflow/environments/environment.js

@@ -1,15 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.builtInEnvJsonReplacer = exports.initializeCleanEnvironments = exports.BuiltInEnvironment = exports.Environment = exports.makeAllMaybe = exports.makeReferenceMaybe = void 0;
+exports.BuiltInEnvironment = exports.Environment = void 0;
+exports.makeReferenceMaybe = makeReferenceMaybe;
+exports.makeAllMaybe = makeAllMaybe;
+exports.initializeCleanEnvironments = initializeCleanEnvironments;
+exports.builtInEnvJsonReplacer = builtInEnvJsonReplacer;
+const identifier_1 = require("./identifier");
 const built_in_1 = require("./built-in");
 const resolve_by_name_1 = require("./resolve-by-name");
 const json_1 = require("../../util/json");
 function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = undefined) {
     const node = graph.get(ref.nodeId, true);
     if (includeDefs) {
-        const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments) : undefined;
+        const definitions = ref.name ? (0, resolve_by_name_1.resolveByName)(ref.name, environments, ref.type) : undefined;
         for (const definition of definitions ?? []) {
-            if (definition.kind !== 'built-in-function' && definition.kind !== 'built-in-value') {
+            if (definition.type !== identifier_1.ReferenceType.BuiltInFunction && definition.type !== identifier_1.ReferenceType.BuiltInConstant) {
                 if (definition.controlDependencies && defaultCd && !definition.controlDependencies.find(c => c.id === defaultCd.id)) {
                     definition.controlDependencies.push(defaultCd);
                 }
@@ -30,14 +35,12 @@ function makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd = u
     }
     return { ...ref, controlDependencies: [...ref.controlDependencies ?? [], ...(defaultCd ? [defaultCd] : [])] };
 }
-exports.makeReferenceMaybe = makeReferenceMaybe;
 function makeAllMaybe(references, graph, environments, includeDefs, defaultCd = undefined) {
     if (references === undefined) {
         return [];
     }
     return references.map(ref => makeReferenceMaybe(ref, graph, environments, includeDefs, defaultCd));
 }
-exports.makeAllMaybe = makeAllMaybe;
 let environmentIdCounter = 0;
 class Environment {
     id = environmentIdCounter++;
@@ -65,7 +68,6 @@ function initializeCleanEnvironments(fullBuiltIns = true) {
         level: 0
     };
 }
-exports.initializeCleanEnvironments = initializeCleanEnvironments;
 function builtInEnvJsonReplacer(k, v) {
     if (v === exports.BuiltInEnvironment) {
         return '<BuiltInEnvironment>';
@@ -77,5 +79,4 @@ function builtInEnvJsonReplacer(k, v) {
         return (0, json_1.jsonReplacer)(k, v);
     }
 }
-exports.builtInEnvJsonReplacer = builtInEnvJsonReplacer;
 //# sourceMappingURL=environment.js.map

package/dataflow/environments/identifier.d.ts

@@ -4,15 +4,35 @@ import type { ControlDependency } from '../info';
 export type Identifier = string & {
     __brand?: 'identifier';
 };
-interface InGraphIdentifierDefinition extends IdentifierReference {
-    kind: 'function' | 'variable' | 'parameter' | 'argument';
-    /** The assignment (or whatever, like `assign` function call) node which ultimately defined this identifier */
-    definedAt: NodeId;
+/**
+ * Each reference only has exactly one reference type, stored as the respective number.
+ * However, wenn checking we may want to allow for one of several types,
+ * allowing the combination of the respective bitmasks.
+ */
+export declare enum ReferenceType {
+    /** The identifier type is unknown */
+    Unknown = 1,
+    /** The identifier is defined by a function (includes built-in function) */
+    Function = 2,
+    /** The identifier is defined by a variable (includes parameter and argument) */
+    Variable = 4,
+    /** The identifier is defined by a constant (includes built-in constant) */
+    Constant = 8,
+    /** The identifier is defined by a parameter (which we know nothing about at the moment) */
+    Parameter = 16,
+    /** The identifier is defined by an argument (which we know nothing about at the moment) */
+    Argument = 32,
+    /** The identifier is defined by a built-in value/constant */
+    BuiltInConstant = 64,
+    /** The identifier is defined by a built-in function */
+    BuiltInFunction = 128
 }
+export declare const ReferenceTypeReverseMapping: Map<ReferenceType, string>;
 /**
- * Stores the definition of an identifier within an {@link IEnvironment}
+ * Check if the reference types have an overlapping type!
  */
-export type IdentifierDefinition = InGraphIdentifierDefinition | BuiltInIdentifierDefinition | BuiltInIdentifierConstant;
+export declare function isReferenceType(t: ReferenceType, target: ReferenceType): boolean;
+export type InGraphReferenceType = Exclude<ReferenceType, ReferenceType.BuiltInConstant | ReferenceType.BuiltInFunction>;
 /**
  * Something like `a` in `b <- a`.
  * Without any surrounding information, `a` will produce the identifier reference `a`.
@@ -23,10 +43,21 @@ export interface IdentifierReference {
     readonly nodeId: NodeId;
     /** Name the reference is identified by (e.g., the name of the variable), undefined if the reference is "artificial" (e.g., anonymous) */
     readonly name: Identifier | undefined;
+    /** Type of the reference to be resolved */
+    readonly type: ReferenceType;
     /**
-     * If the reference is only effective if, e.g. an if-then-else condition is true, this references the root of the `if`.
-     * As a hackey intermediate solution (until we have pointer-analysis), an empty array may indicate a `maybe` which is due to pointer access (e.g., in `a[x] <- 3`).
+     * If the reference is only effective, if, for example, an if-then-else condition is true, this references the root of the `if`.
+     * As a hacky intermediate solution (until we have pointer-analysis), an empty array may indicate a `maybe` which is due to pointer access (e.g., in `a[x] <- 3`).
      */
     controlDependencies: ControlDependency[] | undefined;
 }
+interface InGraphIdentifierDefinition extends IdentifierReference {
+    readonly type: InGraphReferenceType;
+    /** The assignment (or whatever, like `assign` function call) node which ultimately defined this identifier */
+    readonly definedAt: NodeId;
+}
+/**
+ * Stores the definition of an identifier within an {@link IEnvironment}
+ */
+export type IdentifierDefinition = InGraphIdentifierDefinition | BuiltInIdentifierDefinition | BuiltInIdentifierConstant;
 export {};

package/dataflow/environments/identifier.js

@@ -1,3 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceTypeReverseMapping = exports.ReferenceType = void 0;
+exports.isReferenceType = isReferenceType;
+/**
+ * Each reference only has exactly one reference type, stored as the respective number.
+ * However, wenn checking we may want to allow for one of several types,
+ * allowing the combination of the respective bitmasks.
+ */
+var ReferenceType;
+(function (ReferenceType) {
+    /** The identifier type is unknown */
+    ReferenceType[ReferenceType["Unknown"] = 1] = "Unknown";
+    /** The identifier is defined by a function (includes built-in function) */
+    ReferenceType[ReferenceType["Function"] = 2] = "Function";
+    /** The identifier is defined by a variable (includes parameter and argument) */
+    ReferenceType[ReferenceType["Variable"] = 4] = "Variable";
+    /** The identifier is defined by a constant (includes built-in constant) */
+    ReferenceType[ReferenceType["Constant"] = 8] = "Constant";
+    /** The identifier is defined by a parameter (which we know nothing about at the moment) */
+    ReferenceType[ReferenceType["Parameter"] = 16] = "Parameter";
+    /** The identifier is defined by an argument (which we know nothing about at the moment) */
+    ReferenceType[ReferenceType["Argument"] = 32] = "Argument";
+    /** The identifier is defined by a built-in value/constant */
+    ReferenceType[ReferenceType["BuiltInConstant"] = 64] = "BuiltInConstant";
+    /** The identifier is defined by a built-in function */
+    ReferenceType[ReferenceType["BuiltInFunction"] = 128] = "BuiltInFunction";
+})(ReferenceType || (exports.ReferenceType = ReferenceType = {}));
+exports.ReferenceTypeReverseMapping = new Map(Object.entries(ReferenceType).map(([k, v]) => [v, k]));
+/**
+ * Check if the reference types have an overlapping type!
+ */
+function isReferenceType(t, target) {
+    return (t & target) !== 0;
+}
 //# sourceMappingURL=identifier.js.map

package/dataflow/environments/overwrite.d.ts

@@ -1,6 +1,7 @@
 import type { REnvironmentInformation, IEnvironment } from './environment';
-export declare function overwriteIEnvironmentWith(base: IEnvironment | undefined, next: IEnvironment | undefined, includeParent?: boolean): IEnvironment;
-export declare function overwriteEnvironment(base: REnvironmentInformation, next: REnvironmentInformation | undefined): REnvironmentInformation;
-export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation): REnvironmentInformation;
-export declare function overwriteEnvironment(base: undefined, next: undefined): undefined;
-export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation | undefined): REnvironmentInformation | undefined;
+import type { ControlDependency } from '../info';
+export declare function overwriteIEnvironmentWith(base: IEnvironment | undefined, next: IEnvironment | undefined, includeParent?: boolean, applyCds?: readonly ControlDependency[]): IEnvironment;
+export declare function overwriteEnvironment(base: REnvironmentInformation, next: REnvironmentInformation | undefined, applyCds?: readonly ControlDependency[]): REnvironmentInformation;
+export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation, applyCds?: readonly ControlDependency[]): REnvironmentInformation;
+export declare function overwriteEnvironment(base: undefined, next: undefined, applyCds?: readonly ControlDependency[]): undefined;
+export declare function overwriteEnvironment(base: REnvironmentInformation | undefined, next: REnvironmentInformation | undefined, applyCds?: readonly ControlDependency[]): REnvironmentInformation | undefined;

package/dataflow/environments/overwrite.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overwriteEnvironment = exports.overwriteIEnvironmentWith = void 0;
+exports.overwriteIEnvironmentWith = overwriteIEnvironmentWith;
+exports.overwriteEnvironment = overwriteEnvironment;
 const assert_1 = require("../../util/assert");
 const environment_1 = require("./environment");
 function anyIsMaybeOrEmpty(values) {
@@ -14,11 +15,11 @@ function anyIsMaybeOrEmpty(values) {
     }
     return false;
 }
-function overwriteIEnvironmentWith(base, next, includeParent = true) {
+function overwriteIEnvironmentWith(base, next, includeParent = true, applyCds) {
     (0, assert_1.guard)(base !== undefined && next !== undefined, 'can not overwrite environments with undefined');
     const map = new Map(base.memory);
     for (const [key, values] of next.memory) {
-        const hasMaybe = anyIsMaybeOrEmpty(values);
+        const hasMaybe = applyCds?.length === 0 || applyCds !== undefined ? true : anyIsMaybeOrEmpty(values);
         if (hasMaybe) {
             const old = map.get(key);
             // we need to make a copy to avoid side effects for old reference in other environments
@@ -26,7 +27,15 @@ function overwriteIEnvironmentWith(base, next, includeParent = true) {
             for (const v of values) {
                 const index = updatedOld.findIndex(o => o.nodeId === v.nodeId && o.definedAt === v.definedAt);
                 if (index < 0) {
-                    updatedOld.push(v);
+                    if (applyCds !== undefined) {
+                        updatedOld.push({
+                            ...v,
+                            controlDependencies: [...applyCds, ...v.controlDependencies ?? []]
+                        });
+                    }
+                    else {
+                        updatedOld.push(v);
+                    }
                 }
             }
             map.set(key, [...updatedOld]);
@@ -37,7 +46,7 @@ function overwriteIEnvironmentWith(base, next, includeParent = true) {
     }
     let parent;
     if (includeParent) {
-        parent = base.parent.id === environment_1.BuiltInEnvironment.id ? environment_1.BuiltInEnvironment : overwriteIEnvironmentWith(base.parent, next.parent);
+        parent = base.parent.id === environment_1.BuiltInEnvironment.id ? environment_1.BuiltInEnvironment : overwriteIEnvironmentWith(base.parent, next.parent, includeParent, applyCds);
     }
     else {
         parent = base.parent;
@@ -46,12 +55,11 @@ function overwriteIEnvironmentWith(base, next, includeParent = true) {
     out.memory = map;
     return out;
 }
-exports.overwriteIEnvironmentWith = overwriteIEnvironmentWith;
 /**
  * Assumes, that all definitions within next replace those within base (given the same name).
  * <b>But</b> if all definitions within next are maybe, then they are appended to the base definitions (updating them to be `maybe` from now on as well), similar to {@link appendEnvironment}.
  */
-function overwriteEnvironment(base, next) {
+function overwriteEnvironment(base, next, applyCds) {
     if (base === undefined) {
         return next;
     }
@@ -60,9 +68,8 @@ function overwriteEnvironment(base, next) {
     }
     (0, assert_1.guard)(next.level === base.level, `cannot overwrite environments with differently nested local scopes, base ${base.level} vs. next ${next.level}. This should not happen.`);
     return {
-        current: overwriteIEnvironmentWith(base.current, next.current),
+        current: overwriteIEnvironmentWith(base.current, next.current, true, applyCds),
         level: base.level
     };
 }
-exports.overwriteEnvironment = overwriteEnvironment;
 //# sourceMappingURL=overwrite.js.map

package/dataflow/environments/resolve-by-name.d.ts

@@ -1,13 +1,15 @@
 import type { REnvironmentInformation } from './environment';
 import { Ternary } from '../../util/logic';
 import type { Identifier, IdentifierDefinition } from './identifier';
+import { ReferenceType } from './identifier';
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *
  * @param name         - The name of the identifier to resolve
  * @param environment  - The current environment used for name resolution
+ * @param target       - The target (meta) type of the identifier to resolve
  *
  * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
  */
-export declare function resolveByName(name: Identifier, environment: REnvironmentInformation): IdentifierDefinition[] | undefined;
+export declare function resolveByName(name: Identifier, environment: REnvironmentInformation, target?: ReferenceType): IdentifierDefinition[] | undefined;
 export declare function resolvesToBuiltInConstant(name: Identifier | undefined, environment: REnvironmentInformation, wantedValue: unknown): Ternary;

package/dataflow/environments/resolve-by-name.js

@@ -1,39 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvesToBuiltInConstant = exports.resolveByName = void 0;
+exports.resolveByName = resolveByName;
+exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
 const environment_1 = require("./environment");
+const identifier_1 = require("./identifier");
+const info_1 = require("../info");
+const FunctionTargetTypes = identifier_1.ReferenceType.Function | identifier_1.ReferenceType.BuiltInFunction | identifier_1.ReferenceType.Unknown | identifier_1.ReferenceType.Argument | identifier_1.ReferenceType.Parameter;
+const VariableTargetTypes = identifier_1.ReferenceType.Variable | identifier_1.ReferenceType.Parameter | identifier_1.ReferenceType.Argument | identifier_1.ReferenceType.Unknown;
+const ConstantTargetTypes = identifier_1.ReferenceType.Constant | identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.Unknown;
+const BuiltInConstantTargetTypes = identifier_1.ReferenceType.BuiltInConstant | identifier_1.ReferenceType.Unknown;
+const BuiltInFunctionTargetTypes = identifier_1.ReferenceType.BuiltInFunction | identifier_1.ReferenceType.Unknown;
+const TargetTypePredicate = {
+    [identifier_1.ReferenceType.Unknown]: () => true,
+    [identifier_1.ReferenceType.Function]: ({ type }) => (0, identifier_1.isReferenceType)(type, FunctionTargetTypes),
+    [identifier_1.ReferenceType.Variable]: ({ type }) => (0, identifier_1.isReferenceType)(type, VariableTargetTypes),
+    [identifier_1.ReferenceType.Constant]: ({ type }) => (0, identifier_1.isReferenceType)(type, ConstantTargetTypes),
+    [identifier_1.ReferenceType.Parameter]: () => true,
+    [identifier_1.ReferenceType.Argument]: () => true,
+    [identifier_1.ReferenceType.BuiltInConstant]: ({ type }) => (0, identifier_1.isReferenceType)(type, BuiltInConstantTargetTypes),
+    [identifier_1.ReferenceType.BuiltInFunction]: ({ type }) => (0, identifier_1.isReferenceType)(type, BuiltInFunctionTargetTypes)
+};
 /**
  * Resolves a given identifier name to a list of its possible definition location using R scoping and resolving rules.
  *
  * @param name         - The name of the identifier to resolve
  * @param environment  - The current environment used for name resolution
+ * @param target       - The target (meta) type of the identifier to resolve
  *
  * @returns A list of possible definitions of the identifier (one if the definition location is exactly and always known), or `undefined` if the identifier is undefined in the current scope/with the current environment information.
  */
-function resolveByName(name, environment) {
+function resolveByName(name, environment, target = identifier_1.ReferenceType.Unknown) {
     let current = environment.current;
+    let definitions = undefined;
+    const wantedType = TargetTypePredicate[target];
     do {
         const definition = current.memory.get(name);
         if (definition !== undefined) {
-            return definition;
+            const filtered = definition.filter(wantedType);
+            if (filtered.length === definition.length && definition.every(d => (0, info_1.happensInEveryBranch)(d.controlDependencies))) {
+                return definition;
+            }
+            else if (filtered.length > 0) {
+                definitions ??= [];
+                definitions.push(...filtered);
+            }
         }
         current = current.parent;
     } while (current.id !== environment_1.BuiltInEnvironment.id);
-    return current.memory.get(name);
+    const builtIns = current.memory.get(name);
+    if (definitions) {
+        return builtIns === undefined ? definitions : [...definitions, ...builtIns];
+    }
+    else {
+        return builtIns;
+    }
 }
-exports.resolveByName = resolveByName;
 function resolvesToBuiltInConstant(name, environment, wantedValue) {
     if (name === undefined) {
         return 2 /* Ternary.Never */;
     }
-    const definition = resolveByName(name, environment);
+    const definition = resolveByName(name, environment, identifier_1.ReferenceType.Constant);
     if (definition === undefined) {
         return 2 /* Ternary.Never */;
     }
     let all = true;
     let some = false;
     for (const def of definition) {
-        if (def.kind === 'built-in-value' && def.value === wantedValue) {
+        if (def.type === identifier_1.ReferenceType.BuiltInConstant && def.value === wantedValue) {
             some = true;
         }
         else {
@@ -47,5 +80,4 @@ function resolvesToBuiltInConstant(name, environment, wantedValue) {
         return some ? 1 /* Ternary.Maybe */ : 2 /* Ternary.Never */;
     }
 }
-exports.resolvesToBuiltInConstant = resolvesToBuiltInConstant;
 //# sourceMappingURL=resolve-by-name.js.map

package/dataflow/environments/scoping.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.popLocalEnvironment = exports.pushLocalEnvironment = void 0;
+exports.pushLocalEnvironment = pushLocalEnvironment;
+exports.popLocalEnvironment = popLocalEnvironment;
 const environment_1 = require("./environment");
 const assert_1 = require("../../util/assert");
 /** Add a new local environment scope to the stack, returns the modified variant - sharing the original environments in the stack (no deep-clone) */
@@ -10,7 +11,6 @@ function pushLocalEnvironment(base) {
         level: base.level + 1
     };
 }
-exports.pushLocalEnvironment = pushLocalEnvironment;
 function popLocalEnvironment(base) {
     (0, assert_1.guard)(base.level > 0, 'cannot remove the global/root environment');
     const parent = base.current.parent;
@@ -20,5 +20,4 @@ function popLocalEnvironment(base) {
         level: base.level - 1
     };
 }
-exports.popLocalEnvironment = popLocalEnvironment;
 //# sourceMappingURL=scoping.js.map

package/dataflow/extractor.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.produceDataFlowGraph = exports.processors = void 0;
+exports.processors = void 0;
+exports.produceDataFlowGraph = produceDataFlowGraph;
 const processor_1 = require("./processor");
 const process_uninteresting_leaf_1 = require("./internal/process/process-uninteresting-leaf");
 const process_symbol_1 = require("./internal/process/process-symbol");
@@ -12,32 +13,33 @@ const process_value_1 = require("./internal/process/process-value");
 const named_call_handling_1 = require("./internal/process/functions/call/named-call-handling");
 const make_argument_1 = require("./internal/process/functions/call/argument/make-argument");
 const range_1 = require("../util/range");
+const type_1 = require("../r-bridge/lang-4.x/ast/model/type");
 const retriever_1 = require("../r-bridge/retriever");
 const environment_1 = require("./environments/environment");
 const built_in_source_1 = require("./internal/process/functions/call/built-in/built-in-source");
 exports.processors = {
-    ["RNumber" /* RType.Number */]: process_value_1.processValue,
-    ["RString" /* RType.String */]: process_value_1.processValue,
-    ["RLogical" /* RType.Logical */]: process_value_1.processValue,
-    ["RComment" /* RType.Comment */]: process_uninteresting_leaf_1.processUninterestingLeaf,
-    ["RLineDirective" /* RType.LineDirective */]: process_uninteresting_leaf_1.processUninterestingLeaf,
-    ["RSymbol" /* RType.Symbol */]: process_symbol_1.processSymbol,
-    ["RAccess" /* RType.Access */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.accessed, ...n.access]),
-    ["RBinaryOp" /* RType.BinaryOp */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.lhs, n.rhs]),
-    ["RPipe" /* RType.Pipe */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.lhs, n.rhs]),
-    ["RUnaryOp" /* RType.UnaryOp */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.operand]),
-    ["RForLoop" /* RType.ForLoop */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.variable, n.vector, n.body]),
-    ["RWhileLoop" /* RType.WhileLoop */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.condition, n.body]),
-    ["RRepeatLoop" /* RType.RepeatLoop */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.body]),
-    ["RIfThenElse" /* RType.IfThenElse */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.condition, n.then, n.otherwise]),
-    ["RBreak" /* RType.Break */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, []),
-    ["RNext" /* RType.Next */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, []),
-    ["RFunctionCall" /* RType.FunctionCall */]: default_call_handling_1.processFunctionCall,
-    ["RFunctionDefinition" /* RType.FunctionDefinition */]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [...n.parameters, n.body]),
-    ["RParameter" /* RType.Parameter */]: process_parameter_1.processFunctionParameter,
-    ["RArgument" /* RType.Argument */]: process_argument_1.processFunctionArgument,
-    ["RExpressionList" /* RType.ExpressionList */]: (n, d) => (0, named_call_handling_1.processNamedCall)({
-        type: "RSymbol" /* RType.Symbol */,
+    [type_1.RType.Number]: process_value_1.processValue,
+    [type_1.RType.String]: process_value_1.processValue,
+    [type_1.RType.Logical]: process_value_1.processValue,
+    [type_1.RType.Comment]: process_uninteresting_leaf_1.processUninterestingLeaf,
+    [type_1.RType.LineDirective]: process_uninteresting_leaf_1.processUninterestingLeaf,
+    [type_1.RType.Symbol]: process_symbol_1.processSymbol,
+    [type_1.RType.Access]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.accessed, ...n.access]),
+    [type_1.RType.BinaryOp]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.lhs, n.rhs]),
+    [type_1.RType.Pipe]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.lhs, n.rhs]),
+    [type_1.RType.UnaryOp]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.operator, [n.operand]),
+    [type_1.RType.ForLoop]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.variable, n.vector, n.body]),
+    [type_1.RType.WhileLoop]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.condition, n.body]),
+    [type_1.RType.RepeatLoop]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.body]),
+    [type_1.RType.IfThenElse]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [n.condition, n.then, n.otherwise]),
+    [type_1.RType.Break]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, []),
+    [type_1.RType.Next]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, []),
+    [type_1.RType.FunctionCall]: default_call_handling_1.processFunctionCall,
+    [type_1.RType.FunctionDefinition]: (n, d) => (0, process_named_call_1.processAsNamedCall)(n, d, n.lexeme, [...n.parameters, n.body]),
+    [type_1.RType.Parameter]: process_parameter_1.processFunctionParameter,
+    [type_1.RType.Argument]: process_argument_1.processFunctionArgument,
+    [type_1.RType.ExpressionList]: (n, d) => (0, named_call_handling_1.processNamedCall)({
+        type: type_1.RType.Symbol,
         info: n.info,
         content: n.grouping?.[0].content ?? '{',
         lexeme: n.grouping?.[0].lexeme ?? '{',
@@ -70,5 +72,4 @@ function produceDataFlowGraph(request, ast) {
     }
     return df;
 }
-exports.produceDataFlowGraph = produceDataFlowGraph;
 //# sourceMappingURL=extractor.js.map