Recognize s3s4 registrations (#2154)

* feat: rough up s4

* feat: rudimentary s3 method recognition

Author: EagleoutIce

src/dataflow/environments/built-in.ts

@@ -3,7 +3,10 @@ import type { DataflowInformation, ExitPoint, ExitPointType } from '../info';
 import { processKnownFunctionCall } from '../internal/process/functions/call/known-call-handling';
 import { processAccess } from '../internal/process/functions/call/built-in/built-in-access';
 import { processIfThenElse } from '../internal/process/functions/call/built-in/built-in-if-then-else';
-import { processAssignment } from '../internal/process/functions/call/built-in/built-in-assignment';
+import {
+	processAssignment,
+	processAssignmentLike
+} from '../internal/process/functions/call/built-in/built-in-assignment';
 import { processSpecialBinOp } from '../internal/process/functions/call/built-in/built-in-special-bin-op';
 import { processPipe } from '../internal/process/functions/call/built-in/built-in-pipe';
 import { processForLoop } from '../internal/process/functions/call/built-in/built-in-for-loop';
@@ -190,6 +193,7 @@ export const BuiltInProcessorMapper = {
 	'builtin:access':              processAccess,
 	'builtin:apply':               processApply,
 	'builtin:assignment':          processAssignment,
+	'builtin:assignment-like':     processAssignmentLike,
 	'builtin:default':             defaultBuiltInProcessor,
 	'builtin:eval':                processEvalCall,
 	'builtin:expression-list':     processExpressionList,

src/dataflow/environments/default-builtin-config.ts

@@ -251,7 +251,8 @@ export const DefaultBuiltinConfig = [
 	{ 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: [':='],                                         processor: 'builtin:assignment',          config: {},                                                                            assumePrimitive: true  },
-	{ type: 'function', names: ['assign'],                                     processor: 'builtin:assignment',          config: { targetVariable: true },                                                      assumePrimitive: true  },
+	{ type: 'function', names: ['assign', 'setGeneric', 'setValidity'],        processor: 'builtin:assignment',          config: { targetVariable: true },                                                      assumePrimitive: true  },
+	{ type: 'function', names: ['setMethod'],                                  processor: 'builtin:assignment-like',     config: { targetVariable: true, canBeReplacement: false, target: { idx: 0, name: 'f' }, source: { idx: 2, name: 'definition' } }, assumePrimitive: true  },
 	{ type: 'function', names: ['delayedAssign'],                              processor: 'builtin:assignment',          config: { quoteSource: true, targetVariable: 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  },
@@ -265,6 +266,7 @@ export const DefaultBuiltinConfig = [
 	{ 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: ['UseMethod', 'NextMethod'],                    processor: 'builtin:apply',               config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true  },
 	{ type: 'function', names: ['.Primitive', '.Internal'],                    processor: 'builtin:apply',               config: { indexOfFunction: 0, unquoteFunction: true, resolveInEnvironment: 'global' }, assumePrimitive: true  },
 	{ type: 'function', names: ['interference'],                               processor: 'builtin:apply',               config: { unquoteFunction: true, nameOfFunctionArgument: 'propensity_integrand', libFn: true },     assumePrimitive: false },
 	{ type: 'function', names: ['ddply'],                                      processor: 'builtin:apply',               config: { unquoteFunction: true, indexOfFunction: 2, nameOfFunctionArgument: '.fun', libFn: true }, assumePrimitive: false },

src/dataflow/internal/process/functions/call/built-in/built-in-assignment.ts

@@ -9,13 +9,11 @@ import type {
 	ParentInformation,
 	RNodeWithParent
 } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RAstNodeBase, Location, RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
+import type { Location, RAstNodeBase, RNode } from '../../../../../../r-bridge/lang-4.x/ast/model/model';
 import type { RSymbol } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { RType } from '../../../../../../r-bridge/lang-4.x/ast/model/type';
-import type {
-	EmptyArgument,
-	RFunctionArgument
-} from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { RFunctionArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import { EmptyArgument } from '../../../../../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import { type NodeId } from '../../../../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { dataflowLogger } from '../../../../../logger';
 import {
@@ -73,6 +71,11 @@ export interface AssignmentConfiguration extends ForceArguments {
 	readonly mayHaveMoreArgs?:     boolean
 }
 
+export interface ExtendedAssignmentConfiguration extends AssignmentConfiguration {
+	readonly source: { idx?: number, name: string};
+	readonly target: { idx?: number, name: string};
+}
+
 function findRootAccess<OtherInfo>(node: RNode<OtherInfo & ParentInformation>): RSymbol<OtherInfo & ParentInformation> | undefined {
 	let current = node;
 	while(current.type === RType.Access) {
@@ -124,6 +127,42 @@ function tryReplacementPassingIndices<OtherInfo>(
 	return info;
 }
 
+/**
+ * In contrast to `processAssignment`, this function allows more flexible handling of assignment-like functions.
+ */
+export function processAssignmentLike<OtherInfo>(
+	name: RSymbol<OtherInfo & ParentInformation>,
+	/* we expect them to be ordered in the sense that we have (source, target): `<source> <- <target>` */
+	args: readonly RFunctionArgument<OtherInfo & ParentInformation>[],
+	rootId: NodeId,
+	data: DataflowProcessorInformation<OtherInfo & ParentInformation>,
+	config: ExtendedAssignmentConfiguration
+): DataflowInformation {
+	const argsWithNames = new Map<string, RFunctionArgument<OtherInfo & ParentInformation>>();
+	const argsWithoutNames: RFunctionArgument<OtherInfo & ParentInformation>[] = [];
+	for(const arg of args) {
+		const name = arg !== EmptyArgument ? arg.name?.content : undefined;
+		if(name !== undefined) {
+			argsWithNames.set(name, arg);
+		} else {
+			argsWithoutNames.push(arg);
+		}
+	}
+	const source = argsWithNames.get(config.source.name) ?? (config.source.idx !== undefined ? argsWithoutNames[config.source.idx] : undefined);
+	const target = argsWithNames.get(config.target.name) ?? (config.target.idx !== undefined ? argsWithoutNames[config.target.idx] : undefined);
+	if(source && target) {
+		args = [target, source];
+	}
+
+	return processAssignment<OtherInfo>(
+		name,
+		args,
+		rootId,
+		data,
+		{ ...config, mayHaveMoreArgs: true }
+	);
+}
+
 /**
  * Processes an assignment, i.e., `<target> <- <source>`.
  * Handling it as a function call \`&lt;-\` `(<target>, <source>)`.

src/documentation/doc-readme.ts

@@ -203,7 +203,7 @@ The following showcases the dependency view of the [Visual Studio Code extension
 
 ![Dependency Analysis](https://raw.githubusercontent.com/flowr-analysis/vscode-flowr/refs/heads/main/media/dependencies.png)
   
-  `), '    ')}
+  `), '    ')} 
 
 * 🚀 **fast call-graph, data-, and control-flow graphs**\\
   Within just [${'<i>' + textWithTooltip(roundToDecimals(await getLatestDfAnalysisTime('"social-science" Benchmark Suite (tree-sitter)'), 1) + ' ms', 'This measurement is automatically fetched from the latest benchmark!') + '</i>'} (as of ${new Date(await getLastBenchmarkUpdate()).toLocaleDateString('en-US', dateOptions)})](${FlowrSiteBaseRef}/wiki/stats/benchmark), 

src/r-bridge/data/data.ts

@@ -725,7 +725,7 @@ ${await printDfGraphForCode(parser, code, { simplified: true })}
 							url:  [
 								{ name: AdvancedR('S3'), href: 'https://adv-r.hadley.nz/s3.html' }
 							],
-							supported:   'not',
+							supported:   'partially',
 							description: '_Handle S3 classes and methods as one unit (with attributes etc.). Including Dispatch and Inheritance._ We do not support typing currently and do not handle objects of these classes "as units."'
 						},
 						{
@@ -734,7 +734,7 @@ ${await printDfGraphForCode(parser, code, { simplified: true })}
 							url:  [
 								{ name: AdvancedR('S4'), href: 'https://adv-r.hadley.nz/s4.html' }
 							],
-							supported:   'not',
+							supported:   'partially',
 							description: '_Handle S4 classes and methods as one unit. Including Dispatch and Inheritance_ We do not support typing currently and do not handle objects of these classes "as units."'
 						},
 						{

test/functionality/dataflow/processing-of-elements/atomic/dataflow-atomic.test.ts

@@ -910,5 +910,37 @@ describe.sequential('Atomic (dataflow information)', withShell(shell => {
 				.constant(1, undefined, false)
 				.reads(6, 0)
 		);
+
+		describe('S4 assign/get', () => {
+			for(const fn of ['setGeneric', 'setValidity']) {
+				assertDataflow(label(fn, ['oop-s4', 'strings', 'implicit-return', 'normal-definition', 'newlines', 'call-normal', 'numbers']),
+					shell, `${fn}("a", function() 1)
+a()`, emptyGraph()
+						.call(9, 'a', [], {
+							returns:     [3],
+							reads:       [1],
+							environment: defaultEnv().defineFunction('a', 1, 7)
+						})
+						.calls(9, 5)
+						.defineVariable(1, '"a"', { definedBy: [7, 5] })
+						.call(7, fn, [argumentInCall(1), argumentInCall(5)], {
+							returns:     [1],
+							onlyBuiltIn: true,
+							reads:       [builtInId(fn), 5],
+							origin:      ['builtin:assignment']
+						})
+						.calls(7, builtInId(fn))
+						.defineFunction(5, [3], {
+							entryPoint:        5,
+							environment:       defaultEnv().pushEnv(),
+							graph:             new Set([3]),
+							in:                [{ nodeId: 3, name: undefined, controlDependencies: [], type: ReferenceType.Constant }],
+							out:               [],
+							unknownReferences: []
+						})
+						.constant(3, undefined, false)
+				);
+			}
+		});
 	});
 }));