feat: support relative paths

docs/README.md

@@ -15,7 +15,7 @@ Safely develop Data Science programs with a statically checked domain specific l
 2. To _execute_ Safe-DS programs, the [Safe-DS Runner](https://github.com/Safe-DS/Runner) has to be installed and
    configured additionally:
     1. Install [Python](https://www.python.org/) (3.11 or 3.12).
-    2. Run `pip install "safe-ds-runner>=0.9.0,<0.10.0"` in a command line to download the latest matching Runner version
+    2. Run `pip install "safe-ds-runner>=0.10.0,<0.11.0"` in a command line to download the latest matching Runner version
        from [PyPI](https://pypi.org/project/safe-ds-runner/).
     3. If the Visual Studio Code extension cannot start the runner, adjust the setting `safe-ds.runner.command`.
        Enter the absolute path to the Runner executable, as seen in the image below.

packages/safe-ds-lang/src/language/generation/safe-ds-python-generator.ts

@@ -3,6 +3,7 @@ import {
     CompositeGeneratorNode,
     expandToNode,
     expandTracedToNode,
+    Generated,
     joinToNode,
     joinTracedToNode,
     NL,
@@ -767,7 +768,6 @@ export class SafeDsPythonGenerator {
             return traceToNode(expression)(frame.getUniqueLambdaBlockName(expression));
         } else if (isSdsCall(expression)) {
             const callable = this.nodeMapper.callToCallable(expression);
-            const sortedArgs = this.sortArguments(getArguments(expression));
             const receiver = this.generateExpression(expression.receiver, frame);
             let call: CompositeGeneratorNode | undefined = undefined;
 
@@ -789,12 +789,12 @@ export class SafeDsPythonGenerator {
                     if (isSdsMemberAccess(expression.receiver)) {
                         thisParam = this.generateExpression(expression.receiver.receiver, frame);
                     }
-                    call = this.generateMemoizedCall(expression, sortedArgs, frame, thisParam);
+                    call = this.generateMemoizedCall(expression, frame, thisParam);
                 }
             }
 
             if (!call) {
-                call = this.generatePlainCall(expression, sortedArgs, frame);
+                call = this.generatePlainCall(expression, frame);
             }
 
             if (expression.isNullSafe) {
@@ -915,11 +915,9 @@ export class SafeDsPythonGenerator {
         throw new Error(`Unknown expression type: ${expression.$type}`);
     }
 
-    private generatePlainCall(
-        expression: SdsCall,
-        sortedArgs: SdsArgument[],
-        frame: GenerationInfoFrame,
-    ): CompositeGeneratorNode {
+    private generatePlainCall(expression: SdsCall, frame: GenerationInfoFrame): CompositeGeneratorNode {
+        const sortedArgs = this.sortArguments(getArguments(expression));
+
         return expandTracedToNode(expression)`${this.generateExpression(expression.receiver, frame)}(${joinTracedToNode(
             expression.argumentList,
             'arguments',
@@ -956,29 +954,23 @@ export class SafeDsPythonGenerator {
         frame.addImport({ importPath: RUNNER_PACKAGE });
         const hiddenParameters = this.getMemoizedCallHiddenParameters(expression, frame);
         const callable = this.nodeMapper.callToCallable(expression);
-        const memoizedArgs = getParameters(callable).map(
-            (parameter) => this.nodeMapper.callToParameterValue(expression, parameter)!,
-        );
         if (isSdsFunction(callable) && !isStatic(callable) && isSdsMemberAccess(expression.receiver)) {
             return expandTracedToNode(
                 expression,
             )`${RUNNER_PACKAGE}.memoized_dynamic_call("${this.getPythonNameOrDefault(
                 callable,
-            )}", lambda *_ : ${generatedPythonCall}, [${thisParam}, ${joinTracedToNode(
-                expression.argumentList,
-                'arguments',
-            )(memoizedArgs, (arg) => this.generateExpression(arg, frame), {
-                separator: ', ',
-            })}], [${joinToNode(hiddenParameters, (param) => param, { separator: ', ' })}])`;
+            )}", lambda *_ : ${generatedPythonCall}, [${thisParam}, ${this.generateMemoizedArgumentList(
+                expression,
+                frame,
+            )}], [${joinToNode(hiddenParameters, (param) => param, { separator: ', ' })}])`;
         }
         return expandTracedToNode(
             expression,
         )`${RUNNER_PACKAGE}.memoized_static_call("${this.generateFullyQualifiedFunctionName(
             expression,
-        )}", lambda *_ : ${generatedPythonCall}, [${joinTracedToNode(expression.argumentList, 'arguments')(
-            memoizedArgs,
-            (arg) => this.generateExpression(arg, frame),
-            { separator: ', ' },
+        )}", lambda *_ : ${generatedPythonCall}, [${this.generateMemoizedArgumentList(
+            expression,
+            frame,
         )}], [${joinToNode(hiddenParameters, (param) => param, { separator: ', ' })}])`;
     }
 
@@ -1019,19 +1011,16 @@ export class SafeDsPythonGenerator {
 
     private generateMemoizedCall(
         expression: SdsCall,
-        sortedArgs: SdsArgument[],
         frame: GenerationInfoFrame,
         thisParam: CompositeGeneratorNode | undefined = undefined,
     ): CompositeGeneratorNode {
         frame.addImport({ importPath: RUNNER_PACKAGE });
         const hiddenParameters = this.getMemoizedCallHiddenParameters(expression, frame);
         const callable = this.nodeMapper.callToCallable(expression);
-        const memoizedArgs = getParameters(callable).map(
-            (parameter) => this.nodeMapper.callToParameterValue(expression, parameter)!,
-        );
+        const parameters = getParameters(callable);
         // For a static function, the thisParam would be the class containing the function. We do not need to generate it in this case
         const generateThisParam = thisParam && isSdsFunction(callable) && !isStatic(callable);
-        const containsOptionalArgs = sortedArgs.some((arg) =>
+        const containsOptionalArgs = getArguments(expression).some((arg) =>
             Parameter.isOptional(this.nodeMapper.argumentToParameter(arg)),
         );
         const fullyQualifiedTargetName = this.generateFullyQualifiedFunctionName(expression);
@@ -1041,15 +1030,12 @@ export class SafeDsPythonGenerator {
             )`${RUNNER_PACKAGE}.memoized_dynamic_call("${this.getPythonNameOrDefault(callable)}", ${
                 containsOptionalArgs ? 'lambda *_ : ' : ''
             }${
-                containsOptionalArgs ? this.generatePlainCall(expression, sortedArgs, frame) : 'None'
+                containsOptionalArgs ? this.generatePlainCall(expression, frame) : 'None'
             }, [${generateThisParam ? thisParam : ''}${
-                generateThisParam && memoizedArgs.length > 0 ? ', ' : ''
-            }${joinTracedToNode(expression.argumentList, 'arguments')(
-                memoizedArgs,
-                (arg) => this.generateExpression(arg, frame),
-                {
-                    separator: ', ',
-                },
+                generateThisParam && parameters.length > 0 ? ', ' : ''
+            }${this.generateMemoizedArgumentList(
+                expression,
+                frame,
             )}], [${joinToNode(hiddenParameters, (param) => param, { separator: ', ' })}])`;
         }
         if (!containsOptionalArgs && isSdsMemberAccess(expression.receiver)) {
@@ -1061,19 +1047,59 @@ export class SafeDsPythonGenerator {
             containsOptionalArgs ? 'lambda *_ : ' : ''
         }${
             containsOptionalArgs
-                ? this.generatePlainCall(expression, sortedArgs, frame)
+                ? this.generatePlainCall(expression, frame)
                 : isSdsMemberAccess(expression.receiver)
                   ? this.getClassQualifiedNameForMember(<SdsClassMember>callable)
                   : this.generateExpression(expression.receiver, frame)
         }, [${generateThisParam ? thisParam : ''}${
-            generateThisParam && memoizedArgs.length > 0 ? ', ' : ''
-        }${joinTracedToNode(expression.argumentList, 'arguments')(
-            memoizedArgs,
-            (arg) => this.generateExpression(arg, frame),
+            generateThisParam && parameters.length > 0 ? ', ' : ''
+        }${this.generateMemoizedArgumentList(
+            expression,
+            frame,
+        )}], [${joinToNode(hiddenParameters, (param) => param, { separator: ', ' })}])`;
+    }
+
+    private generateMemoizedArgumentList(node: SdsCall, frame: GenerationInfoFrame): Generated {
+        const callable = this.nodeMapper.callToCallable(node);
+        const parameters = getParameters(callable);
+        const parametersToArgument = this.nodeMapper.parametersToArguments(parameters, getArguments(node));
+
+        return joinTracedToNode(node.argumentList, 'arguments')(
+            parameters,
+            (parameter) => {
+                const argument = parametersToArgument.get(parameter);
+                return this.generateMemoizedArgument(argument, parameter, frame);
+            },
             {
                 separator: ', ',
             },
-        )}], [${joinToNode(hiddenParameters, (param) => param, { separator: ', ' })}])`;
+        );
+    }
+
+    private generateMemoizedArgument(
+        argument: SdsArgument | undefined,
+        parameter: SdsParameter,
+        frame: GenerationInfoFrame,
+    ): Generated {
+        const value = argument?.value ?? parameter?.defaultValue;
+        if (!value) {
+            /* c8 ignore next 2 */
+            throw new Error(`No value passed for required parameter "${parameter.name}".`);
+        }
+
+        const result = this.generateExpression(value, frame);
+        if (!this.isMemoizedPath(parameter)) {
+            return result;
+        }
+
+        frame.addImport({ importPath: RUNNER_PACKAGE });
+        return expandToNode`${RUNNER_PACKAGE}.absolute_path(${result})`;
+    }
+
+    private isMemoizedPath(parameter: SdsParameter): boolean {
+        const callable = AstUtils.getContainerOfType(parameter, isSdsCallable);
+        const impurityReasons = this.purityComputer.getImpurityReasonsForCallable(callable);
+        return impurityReasons.some((reason) => reason instanceof FileRead && reason.path === parameter);
     }
 
     private getMemoizedCallHiddenParameters(expression: SdsCall, frame: GenerationInfoFrame): CompositeGeneratorNode[] {

packages/safe-ds-lang/src/language/runner/messages.ts

@@ -33,6 +33,7 @@ export interface ProgramMessage {
 export interface ProgramPackageMap {
     code: ProgramCodeMap;
     main: ProgramMainInformation;
+    cwd?: string;
 }
 
 /**

packages/safe-ds-lang/src/language/runner/safe-ds-runner.ts

@@ -24,8 +24,8 @@ import { SafeDsMessagingProvider } from '../lsp/safe-ds-messaging-provider.js';
 
 export const RPC_RUNNER_STARTED = 'runner/started';
 
-const LOWEST_SUPPORTED_VERSION = '0.9.0';
-const LOWEST_UNSUPPORTED_VERSION = '0.10.0';
+const LOWEST_SUPPORTED_VERSION = '0.10.0';
+const LOWEST_UNSUPPORTED_VERSION = '0.11.0';
 const npmVersionRange = `>=${LOWEST_SUPPORTED_VERSION} <${LOWEST_UNSUPPORTED_VERSION}`;
 const pipVersionRange = `>=${LOWEST_SUPPORTED_VERSION},<${LOWEST_UNSUPPORTED_VERSION}`;
 
@@ -397,6 +397,7 @@ export class SafeDsRunner {
                     module: mainModuleName,
                     pipeline: pipelineName,
                 },
+                cwd: path.parse(pipelineDocument.uri.fsPath).dir,
             }),
         );
     }

packages/safe-ds-lang/tests/resources/generation/python/runner integration/expressions/member access/generated/tests/generator/memberAccessWithRunnerIntegration/gen_input.py

@@ -38,10 +38,10 @@ def test():
     f(safeds_runner.memoized_dynamic_call("m", lambda *_ : safeds_runner.memoized_static_call("tests.generator.memberAccessWithRunnerIntegration.C.o", C.o, [42], []).m(param=213), [safeds_runner.memoized_static_call("tests.generator.memberAccessWithRunnerIntegration.C.o", C.o, [42], []), 213], []))
     f(safeds_runner.memoized_dynamic_call("j", None, [safeds_runner.memoized_static_call("tests.generator.memberAccessWithRunnerIntegration.C.o", C.o, [42], []), 213], []))
     f(safeds_runner.memoized_dynamic_call("j", None, [safeds_runner.memoized_static_call("tests.generator.memberAccessWithRunnerIntegration.C.p", C.p, [], []), 213], []))
-    f(safeds_runner.memoized_static_call("tests.generator.memberAccessWithRunnerIntegration.C.from_csv_file", C.from_csv_file, ['abc.csv'], [safeds_runner.file_mtime('abc.csv')]))
-    a = safeds_runner.memoized_static_call("safeds.data.tabular.containers.Table.from_csv_file", Table.from_csv_file, ['abc.csv'], [safeds_runner.file_mtime('abc.csv')])
+    f(safeds_runner.memoized_static_call("tests.generator.memberAccessWithRunnerIntegration.C.from_csv_file", C.from_csv_file, [safeds_runner.absolute_path('abc.csv')], [safeds_runner.file_mtime('abc.csv')]))
+    a = safeds_runner.memoized_static_call("safeds.data.tabular.containers.Table.from_csv_file", Table.from_csv_file, [safeds_runner.absolute_path('abc.csv')], [safeds_runner.file_mtime('abc.csv')])
     safeds_runner.save_placeholder('a', a)
-    a2 = safeds_runner.memoized_dynamic_call("remove_columns", None, [safeds_runner.memoized_static_call("safeds.data.tabular.containers.Table.from_csv_file", Table.from_csv_file, ['abc.csv'], [safeds_runner.file_mtime('abc.csv')]), ['u']], [])
+    a2 = safeds_runner.memoized_dynamic_call("remove_columns", None, [safeds_runner.memoized_static_call("safeds.data.tabular.containers.Table.from_csv_file", Table.from_csv_file, [safeds_runner.absolute_path('abc.csv')], [safeds_runner.file_mtime('abc.csv')]), ['u']], [])
     safeds_runner.save_placeholder('a2', a2)
     v = safeds_runner.memoized_dynamic_call("get_column", None, [a, 'b'], [])
     safeds_runner.save_placeholder('v', v)