feat: python server (runtime)

.eslintrc.cjs

@@ -17,7 +17,7 @@ module.exports = {
     },
     overrides: [
         {
-            files: ['packages/safe-ds-cli/src/**'],
+            files: ['packages/safe-ds-cli/src/**', 'packages/safe-ds-vscode/src/extension/output.ts'],
             rules: {
                 'no-console': 'off',
             },

.vscode/launch.json

@@ -6,7 +6,8 @@
             "args": ["--extensionDevelopmentPath=${workspaceFolder}/packages/safe-ds-vscode"],
             "preLaunchTask": "npm: build",
             "request": "launch",
-            "type": "extensionHost"
+            "type": "extensionHost",
+            "sourceMaps": true
         }
     ]
 }

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

@@ -97,6 +97,7 @@ const BLOCK_LAMBDA_RESULT_PREFIX = `${CODEGEN_PREFIX}block_lambda_result_`;
 const YIELD_PREFIX = `${CODEGEN_PREFIX}yield_`;
 
 const RUNNER_CODEGEN_PACKAGE = 'safeds_runner.codegen';
+const RUNNER_SERVER_PIPELINE_MANAGER_PACKAGE = 'safeds_runner.server.pipeline_manager';
 const PYTHON_INDENT = '    ';
 
 const NLNL = new CompositeGeneratorNode(NL, NL);
@@ -138,7 +139,7 @@ export class SafeDsPythonGenerator {
             );
         }
         generatedFiles.set(pythonOutputPath, text);
-        for (const pipeline of streamAllContents(node).filter(isSdsPipeline)) {
+        for (const pipeline of getModuleMembers(node).filter(isSdsPipeline)) {
             const entryPointFilename = `${path.join(
                 parentDirectoryPath,
                 `${this.formatGeneratedFileName(name)}_${this.getPythonNameOrDefault(pipeline)}`,
@@ -313,7 +314,7 @@ export class SafeDsPythonGenerator {
     }
 
     private generatePipeline(pipeline: SdsPipeline, importSet: Map<String, ImportData>): CompositeGeneratorNode {
-        const infoFrame = new GenerationInfoFrame(importSet);
+        const infoFrame = new GenerationInfoFrame(importSet, true);
         return expandTracedToNode(pipeline)`def ${traceToNode(
             pipeline,
             'name',
@@ -358,19 +359,31 @@ export class SafeDsPythonGenerator {
         }
     }
 
-    private generateBlock(block: SdsBlock, frame: GenerationInfoFrame): CompositeGeneratorNode {
+    private generateBlock(
+        block: SdsBlock,
+        frame: GenerationInfoFrame,
+        generateLambda: boolean = false,
+    ): CompositeGeneratorNode {
         let statements = getStatements(block).filter((stmt) => this.purityComputer.statementDoesSomething(stmt));
         if (statements.length === 0) {
             return traceToNode(block)('pass');
         }
-        return joinTracedToNode(block, 'statements')(statements, (stmt) => this.generateStatement(stmt, frame), {
-            separator: NL,
-        })!;
+        return joinTracedToNode(block, 'statements')(
+            statements,
+            (stmt) => this.generateStatement(stmt, frame, generateLambda),
+            {
+                separator: NL,
+            },
+        )!;
     }
 
-    private generateStatement(statement: SdsStatement, frame: GenerationInfoFrame): CompositeGeneratorNode {
+    private generateStatement(
+        statement: SdsStatement,
+        frame: GenerationInfoFrame,
+        generateLambda: boolean,
+    ): CompositeGeneratorNode {
         if (isSdsAssignment(statement)) {
-            return traceToNode(statement)(this.generateAssignment(statement, frame));
+            return traceToNode(statement)(this.generateAssignment(statement, frame, generateLambda));
         } else if (isSdsExpressionStatement(statement)) {
             const blockLambdaCode: CompositeGeneratorNode[] = [];
             for (const lambda of streamAllContents(statement.expression).filter(isSdsBlockLambda)) {
@@ -386,28 +399,49 @@ export class SafeDsPythonGenerator {
         throw new Error(`Unknown SdsStatement: ${statement}`);
     }
 
-    private generateAssignment(assignment: SdsAssignment, frame: GenerationInfoFrame): CompositeGeneratorNode {
+    private generateAssignment(
+        assignment: SdsAssignment,
+        frame: GenerationInfoFrame,
+        generateLambda: boolean,
+    ): CompositeGeneratorNode {
         const requiredAssignees = isSdsCall(assignment.expression)
             ? getAbstractResults(this.nodeMapper.callToCallable(assignment.expression)).length
             : /* c8 ignore next */
               1;
         const assignees = getAssignees(assignment);
         if (assignees.some((value) => !isSdsWildcard(value))) {
             const actualAssignees = assignees.map(this.generateAssignee);
+            let assignmentStatements = [];
             if (requiredAssignees === actualAssignees.length) {
-                return expandTracedToNode(assignment)`${joinToNode(
-                    actualAssignees,
-                    (actualAssignee) => actualAssignee,
-                    { separator: ', ' },
-                )} = ${this.generateExpression(assignment.expression!, frame)}`;
+                assignmentStatements.push(
+                    expandTracedToNode(assignment)`${joinToNode(actualAssignees, (actualAssignee) => actualAssignee, {
+                        separator: ', ',
+                    })} = ${this.generateExpression(assignment.expression!, frame)}`,
+                );
             } else {
                 // Add wildcards to match given results
-                return expandTracedToNode(assignment)`${joinToNode(
-                    actualAssignees.concat(Array(requiredAssignees - actualAssignees.length).fill('_')),
-                    (actualAssignee) => actualAssignee,
-                    { separator: ', ' },
-                )} = ${this.generateExpression(assignment.expression!, frame)}`;
+                assignmentStatements.push(
+                    expandTracedToNode(assignment)`${joinToNode(
+                        actualAssignees.concat(Array(requiredAssignees - actualAssignees.length).fill('_')),
+                        (actualAssignee) => actualAssignee,
+                        { separator: ', ' },
+                    )} = ${this.generateExpression(assignment.expression!, frame)}`,
+                );
+            }
+            if (frame.isInsidePipeline() && !generateLambda) {
+                for (const savableAssignment of assignees.filter(isSdsPlaceholder)) {
+                    // should always be SdsPlaceholder
+                    frame.addImport({ importPath: RUNNER_SERVER_PIPELINE_MANAGER_PACKAGE });
+                    assignmentStatements.push(
+                        expandTracedToNode(
+                            savableAssignment,
+                        )`${RUNNER_SERVER_PIPELINE_MANAGER_PACKAGE}.runner_save_placeholder('${savableAssignment.name}', ${savableAssignment.name})`,
+                    );
+                }
             }
+            return joinTracedToNode(assignment)(assignmentStatements, (stmt) => stmt, {
+                separator: NL,
+            })!;
         } else {
             return traceToNode(assignment)(this.generateExpression(assignment.expression!, frame));
         }
@@ -435,7 +469,7 @@ export class SafeDsPythonGenerator {
 
     private generateBlockLambda(blockLambda: SdsBlockLambda, frame: GenerationInfoFrame): CompositeGeneratorNode {
         const results = streamBlockLambdaResults(blockLambda).toArray();
-        let lambdaBlock = this.generateBlock(blockLambda.body, frame);
+        let lambdaBlock = this.generateBlock(blockLambda.body, frame, true);
         if (results.length !== 0) {
             lambdaBlock.appendNewLine();
             lambdaBlock.append(
@@ -773,10 +807,12 @@ interface ImportData {
 class GenerationInfoFrame {
     private readonly blockLambdaManager: IdManager<SdsBlockLambda>;
     private readonly importSet: Map<String, ImportData>;
+    private readonly insidePipeline: boolean;
 
-    constructor(importSet: Map<String, ImportData> = new Map<String, ImportData>()) {
+    constructor(importSet: Map<String, ImportData> = new Map<String, ImportData>(), insidePipeline: boolean = false) {
         this.blockLambdaManager = new IdManager<SdsBlockLambda>();
         this.importSet = importSet;
+        this.insidePipeline = insidePipeline;
     }
 
     addImport(importData: ImportData | undefined) {
@@ -791,6 +827,10 @@ class GenerationInfoFrame {
     getUniqueLambdaBlockName(lambda: SdsBlockLambda): string {
         return `${BLOCK_LAMBDA_PREFIX}${this.blockLambdaManager.assignId(lambda)}`;
     }
+
+    isInsidePipeline(): boolean {
+        return this.insidePipeline;
+    }
 }
 
 export interface GenerateOptions {

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

@@ -3,3 +3,4 @@ export * as ast from './generated/ast.js';
 export { SafeDsLanguageMetaData } from './generated/module.js';
 export { startLanguageServer } from './main.js';
 export { createSafeDsServices, createSafeDsServicesWithBuiltins } from './safe-ds-module.js';
+export { SAFE_DS_FILE_EXTENSIONS } from './helpers/fileExtensions.js';

packages/safe-ds-lang/tests/resources/generation/statements/assignment/input.sdstest

@@ -11,6 +11,10 @@ pipeline testPipeline {
     val x = g();
     f1(a);
     f1(x);
+    val l, val m, val n = g();
+    f1(l);
+    f1(m);
+    f1(n);
 
     f2(() {
         _, _ ,_ = g();

packages/safe-ds-lang/tests/resources/generation/statements/assignment/output/tests/generator/assignment/gen_input.py

@@ -1,3 +1,7 @@
+# Imports ----------------------------------------------------------------------
+
+import safeds_runner.server.pipeline_manager
+
 # Segments ---------------------------------------------------------------------
 
 def testSegment():
@@ -13,9 +17,18 @@ def testSegment():
 def testPipeline():
     g()
     a, _, _ = g()
+    safeds_runner.server.pipeline_manager.runner_save_placeholder('a', a)
     x, _, _ = g()
+    safeds_runner.server.pipeline_manager.runner_save_placeholder('x', x)
     f1(a)
     f1(x)
+    l, m, n = g()
+    safeds_runner.server.pipeline_manager.runner_save_placeholder('l', l)
+    safeds_runner.server.pipeline_manager.runner_save_placeholder('m', m)
+    safeds_runner.server.pipeline_manager.runner_save_placeholder('n', n)
+    f1(l)
+    f1(m)
+    f1(n)
     def __gen_block_lambda_0():
         g()
         a, _, __gen_block_lambda_result_c = g()

packages/safe-ds-vscode/esbuild.mjs

@@ -33,6 +33,13 @@ const plugins = [
         },
         watch,
     }),
+    copy({
+            assets: {
+                from: ['../../node_modules/source-map/lib/mappings.wasm'],
+                to: ['./extension']
+            }
+        }
+    ),
     {
         name: 'watch-plugin',
         setup(build) {

packages/safe-ds-vscode/package.json

@@ -83,6 +83,11 @@
         "configuration": {
             "title": "Safe-DS",
             "properties": {
+                "safe-ds.runner.command": {
+                    "description": "Command to start the Safe-DS runner",
+                    "type": "string",
+                    "default": "safe-ds-runner"
+                },
                 "safe-ds.validation.codeStyle": {
                     "type": "boolean",
                     "default": true,
@@ -112,6 +117,23 @@
                 "files.trimTrailingWhitespace": true
             }
         },
+        "menus": {
+            "editor/title/run": [
+                {
+                    "command": "extension.safe-ds.runPipelineFile",
+                    "when": "resourceLangId == safe-ds",
+                    "group": "navigation@1"
+                }
+            ]
+        },
+        "commands": [
+            {
+                "command": "extension.safe-ds.runPipelineFile",
+                "title": "Run Pipeline",
+                "category": "Safe-DS",
+                "icon": "$(play)"
+            }
+        ],
         "snippets": [
             {
                 "language": "safe-ds",
@@ -131,11 +153,14 @@
         "deploy": "vsce publish"
     },
     "dependencies": {
-        "vscode-languageclient": "^9.0.1"
+        "source-map": "^0.7.4",
+        "vscode-languageclient": "^9.0.1",
+        "ws": "^8.14.2"
     },
     "devDependencies": {
         "@types/node": "^18.18.12",
         "@types/vscode": "^1.84.2",
+        "@types/ws": "^8.5.8",
         "@vscode/vsce": "^2.22.0",
         "esbuild": "^0.19.8",
         "esbuild-plugin-copy": "^2.1.1"