feat: generate nested functions for expression lambdas (#1062)

### Summary of Changes

For expression lambdas, we now also generate nested functions instead of
Python lambdas. This is
1. more readable,
2. better for memoization, since we use the source code of a callable
for lookup and Python is not able to return *only* the source code of a
lambda.

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

@@ -60,6 +60,8 @@ import {
     SdsClassMember,
     SdsDeclaration,
     SdsExpression,
+    SdsExpressionLambda,
+    SdsLambda,
     SdsModule,
     SdsParameter,
     SdsParameterList,
@@ -100,7 +102,7 @@ import { NamedTupleType } from '../typing/model.js';
 import { getOutermostContainerOfType } from '../helpers/astUtils.js';
 
 export const CODEGEN_PREFIX = '__gen_';
-const BLOCK_LAMBDA_PREFIX = `${CODEGEN_PREFIX}block_lambda_`;
+const LAMBDA_PREFIX = `${CODEGEN_PREFIX}lambda_`;
 const BLOCK_LAMBDA_RESULT_PREFIX = `${CODEGEN_PREFIX}block_lambda_result_`;
 const YIELD_PREFIX = `${CODEGEN_PREFIX}yield_`;
 
@@ -593,23 +595,31 @@ export class SafeDsPythonGenerator {
         frame: GenerationInfoFrame,
         generateLambda: boolean,
     ): CompositeGeneratorNode {
-        const blockLambdaCode: CompositeGeneratorNode[] = [];
+        const result: CompositeGeneratorNode[] = [];
         if (isSdsAssignment(statement)) {
             if (statement.expression) {
-                for (const lambda of AstUtils.streamAllContents(statement.expression).filter(isSdsBlockLambda)) {
-                    blockLambdaCode.push(this.generateBlockLambda(lambda, frame));
+                for (const node of AstUtils.streamAllContents(statement.expression)) {
+                    if (isSdsBlockLambda(node)) {
+                        result.push(this.generateBlockLambda(node, frame));
+                    } else if (isSdsExpressionLambda(node)) {
+                        result.push(this.generateExpressionLambda(node, frame));
+                    }
                 }
             }
-            blockLambdaCode.push(this.generateAssignment(statement, frame, generateLambda));
-            return joinTracedToNode(statement)(blockLambdaCode, (stmt) => stmt, {
+            result.push(this.generateAssignment(statement, frame, generateLambda));
+            return joinTracedToNode(statement)(result, (stmt) => stmt, {
                 separator: NL,
             })!;
         } else if (isSdsExpressionStatement(statement)) {
-            for (const lambda of AstUtils.streamAllContents(statement.expression).filter(isSdsBlockLambda)) {
-                blockLambdaCode.push(this.generateBlockLambda(lambda, frame));
+            for (const node of AstUtils.streamAllContents(statement.expression)) {
+                if (isSdsBlockLambda(node)) {
+                    result.push(this.generateBlockLambda(node, frame));
+                } else if (isSdsExpressionLambda(node)) {
+                    result.push(this.generateExpressionLambda(node, frame));
+                }
             }
-            blockLambdaCode.push(this.generateExpression(statement.expression, frame));
-            return joinTracedToNode(statement)(blockLambdaCode, (stmt) => stmt, {
+            result.push(this.generateExpression(statement.expression, frame));
+            return joinTracedToNode(statement)(result, (stmt) => stmt, {
                 separator: NL,
             })!;
         }
@@ -701,7 +711,7 @@ export class SafeDsPythonGenerator {
                 )}`,
             );
         }
-        return expandTracedToNode(blockLambda)`def ${frame.getUniqueLambdaBlockName(
+        return expandTracedToNode(blockLambda)`def ${frame.getUniqueLambdaName(
             blockLambda,
         )}(${this.generateParameters(blockLambda.parameterList, frame)}):`
             .appendNewLine()
@@ -711,6 +721,17 @@ export class SafeDsPythonGenerator {
             });
     }
 
+    private generateExpressionLambda(node: SdsExpressionLambda, frame: GenerationInfoFrame): CompositeGeneratorNode {
+        const name = frame.getUniqueLambdaName(node);
+        const parameters = this.generateParameters(node.parameterList, frame);
+        const result = this.generateExpression(node.result, frame);
+
+        return expandTracedToNode(node)`
+            def ${name}(${parameters}):
+                return ${result}
+        `;
+    }
+
     private generateExpression(expression: SdsExpression, frame: GenerationInfoFrame): CompositeGeneratorNode {
         if (isSdsTemplateStringPart(expression)) {
             if (isSdsTemplateStringStart(expression)) {
@@ -765,7 +786,7 @@ export class SafeDsPythonGenerator {
                 { separator: ', ' },
             )}]`;
         } else if (isSdsBlockLambda(expression)) {
-            return traceToNode(expression)(frame.getUniqueLambdaBlockName(expression));
+            return traceToNode(expression)(frame.getUniqueLambdaName(expression));
         } else if (isSdsCall(expression)) {
             const callable = this.nodeMapper.callToCallable(expression);
             const receiver = this.generateExpression(expression.receiver, frame);
@@ -807,10 +828,7 @@ export class SafeDsPythonGenerator {
                 return call;
             }
         } else if (isSdsExpressionLambda(expression)) {
-            return expandTracedToNode(expression)`lambda ${this.generateParameters(
-                expression.parameterList,
-                frame,
-            )}: ${this.generateExpression(expression.result, frame)}`;
+            return traceToNode(expression)(frame.getUniqueLambdaName(expression));
         } else if (isSdsInfixOperation(expression)) {
             const leftOperand = this.generateExpression(expression.leftOperand, frame);
             const rightOperand = this.generateExpression(expression.rightOperand, frame);
@@ -1260,7 +1278,7 @@ interface ImportData {
 }
 
 class GenerationInfoFrame {
-    private readonly blockLambdaManager: IdManager<SdsBlockLambda>;
+    private readonly lambdaManager: IdManager<SdsLambda>;
     private readonly importSet: Map<String, ImportData>;
     private readonly utilitySet: Set<UtilityFunction>;
     private readonly typeVariableSet: Set<string>;
@@ -1276,7 +1294,7 @@ class GenerationInfoFrame {
         targetPlaceholder: string | undefined = undefined,
         disableRunnerIntegration: boolean = false,
     ) {
-        this.blockLambdaManager = new IdManager<SdsBlockLambda>();
+        this.lambdaManager = new IdManager();
         this.importSet = importSet;
         this.utilitySet = utilitySet;
         this.typeVariableSet = typeVariableSet;
@@ -1312,8 +1330,8 @@ class GenerationInfoFrame {
         }
     }
 
-    getUniqueLambdaBlockName(lambda: SdsBlockLambda): string {
-        return `${BLOCK_LAMBDA_PREFIX}${this.blockLambdaManager.assignId(lambda)}`;
+    getUniqueLambdaName(lambda: SdsLambda): string {
+        return `${LAMBDA_PREFIX}${this.lambdaManager.assignId(lambda)}`;
     }
 }
 

packages/safe-ds-lang/tests/resources/generation/python/declarations/parameter with python name/generated/tests/generator/parameterWithPythonName/gen_input.py

@@ -5,7 +5,9 @@
 # Segments ---------------------------------------------------------------------
 
 def test(param1, param_2, param_3=0):
-    f1(lambda a, b, c=0: 1)
-    def __gen_block_lambda_0(a, b, c=0):
+    def __gen_lambda_0(a, b, c=0):
+        return 1
+    f1(__gen_lambda_0)
+    def __gen_lambda_1(a, b, c=0):
         pass
-    f2(__gen_block_lambda_0)
+    f2(__gen_lambda_1)

packages/safe-ds-lang/tests/resources/generation/python/expressions/block lambda result/generated/tests/generator/blockLambdaResult/gen_input.py

@@ -14,12 +14,12 @@ def f2(l):
 # Pipelines --------------------------------------------------------------------
 
 def test():
-    def __gen_block_lambda_0(a, b):
+    def __gen_lambda_0(a, b):
         __gen_block_lambda_result_d = g()
         return __gen_block_lambda_result_d
-    f1(__gen_block_lambda_0)
-    def __gen_block_lambda_1(a, b):
+    f1(__gen_lambda_0)
+    def __gen_lambda_1(a, b):
         __gen_block_lambda_result_d = g()
         __gen_block_lambda_result_e = g()
         return __gen_block_lambda_result_d, __gen_block_lambda_result_e
-    f2(__gen_block_lambda_1)
+    f2(__gen_lambda_1)

packages/safe-ds-lang/tests/resources/generation/python/expressions/block lambda/generated/tests/generator/blockLambda/gen_input.py

@@ -5,23 +5,23 @@
 # Pipelines --------------------------------------------------------------------
 
 def test():
-    def __gen_block_lambda_0(a, b=2):
+    def __gen_lambda_0(a, b=2):
         __gen_block_lambda_result_d = g()
         return __gen_block_lambda_result_d
-    f1(__gen_block_lambda_0)
-    def __gen_block_lambda_1(a, b):
+    f1(__gen_lambda_0)
+    def __gen_lambda_1(a, b):
         __gen_block_lambda_result_d = g()
         return __gen_block_lambda_result_d
-    f1(__gen_block_lambda_1)
-    def __gen_block_lambda_2():
+    f1(__gen_lambda_1)
+    def __gen_lambda_2():
         pass
-    f2(__gen_block_lambda_2)
-    def __gen_block_lambda_3(a, b=2):
+    f2(__gen_lambda_2)
+    def __gen_lambda_3(a, b=2):
         __gen_block_lambda_result_d = g()
         return __gen_block_lambda_result_d
-    g2(f3(__gen_block_lambda_3))
-    def __gen_block_lambda_4(a, b=2):
+    g2(f3(__gen_lambda_3))
+    def __gen_lambda_4(a, b=2):
         __gen_block_lambda_result_d = g()
         return __gen_block_lambda_result_d
-    c = f3(__gen_block_lambda_4)
+    c = f3(__gen_lambda_4)
     g2(c)

packages/safe-ds-lang/tests/resources/generation/python/expressions/expression lambda/generated/tests/generator/expressionLambda/gen_input.py

@@ -5,5 +5,9 @@
 # Pipelines --------------------------------------------------------------------
 
 def test():
-    f(lambda a, b=2: 1)
-    f(lambda a, b: 1)
+    def __gen_lambda_0(a, b=2):
+        return 1
+    f(__gen_lambda_0)
+    def __gen_lambda_1(a, b):
+        return 1
+    f(__gen_lambda_1)

packages/safe-ds-lang/tests/resources/generation/python/partial/impure dependency/generated/tests/generator/partialImpureDependency/gen_input.py

@@ -10,11 +10,11 @@ def testPipeline():
     impureFileWrite2 = iFileWrite()
     pureValueForImpure2 = noPartialEvalInt(2)
     pureValueForImpure3 = 3
-    def __gen_block_lambda_0():
+    def __gen_lambda_0():
         i1(1)
         __gen_block_lambda_result_r = 1
         return __gen_block_lambda_result_r
-    fp(__gen_block_lambda_0)
+    fp(__gen_lambda_0)
     i1(1)
     impureA1 = i1(pureValueForImpure2)
     impureA2 = i1(noPartialEvalInt(3))

packages/safe-ds-lang/tests/resources/generation/python/partial/pure dependency/generated/tests/generator/partialPureDependency/gen_input.py

@@ -12,14 +12,16 @@ def testPipeline():
     lStrMulti = 'multi\nline'
     boolean1 = True
     value1 = g(True, -1.0, 1, None, 'multi\nline')
-    def __gen_block_lambda_0():
+    def __gen_lambda_0():
         i = 1
         i2 = 3
         j = 6
         j2 = 4
         __gen_block_lambda_result_z = 7
         return __gen_block_lambda_result_z
-    o = (f(__gen_block_lambda_0)) + (f(lambda : 2))
+    def __gen_lambda_1():
+        return 2
+    o = (f(__gen_lambda_0)) + (f(__gen_lambda_1))
     mapKey = 'key'
     mapValue = 'value'
     mapResult = g2({'key': 'value'})

packages/safe-ds-lang/tests/resources/generation/python/runner integration/expressions/calls/main/generated/tests/generator/runnerIntegration/expressions/calls/main/gen_input.py

@@ -39,20 +39,30 @@ def test():
     __gen_null_safe_call(j, lambda: 'abc'.j(123))
     __gen_null_safe_call(k, lambda: k(456, 1.23))
     f(safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.readFile", readFile, [], [safeds_runner.file_mtime('a.txt')]))
-    f(l(lambda a: segment_a(a)))
-    f(l(lambda a: (3) * (segment_a(a))))
-    f(l(lambda a: safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [(3) * (segment_a(a))], [])))
-    f(l(lambda a: (3) * (safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [(3) * (segment_a(a))], [])], []))))
-    def __gen_block_lambda_0(a):
+    def __gen_lambda_0(a):
+        return segment_a(a)
+    f(l(__gen_lambda_0))
+    def __gen_lambda_1(a):
+        return (3) * (segment_a(a))
+    f(l(__gen_lambda_1))
+    def __gen_lambda_2(a):
+        return safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [(3) * (segment_a(a))], [])
+    f(l(__gen_lambda_2))
+    def __gen_lambda_3(a):
+        return (3) * (safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [(3) * (segment_a(a))], [])], []))
+    f(l(__gen_lambda_3))
+    def __gen_lambda_4(a):
         __gen_block_lambda_result_result = segment_a(a)
         return __gen_block_lambda_result_result
-    f(l(__gen_block_lambda_0))
-    def __gen_block_lambda_1(a):
+    f(l(__gen_lambda_4))
+    def __gen_lambda_5(a):
         __gen_block_lambda_result_result = safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [segment_a(a)], [])
         return __gen_block_lambda_result_result
-    f(l(__gen_block_lambda_1))
-    f(safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.l", l, [lambda a: (3) * (a)], []))
-    def __gen_block_lambda_2(a):
+    f(l(__gen_lambda_5))
+    def __gen_lambda_6(a):
+        return (3) * (a)
+    f(safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.l", l, [__gen_lambda_6], []))
+    def __gen_lambda_7(a):
         __gen_block_lambda_result_result = (3) * (safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.m", m, [a], []))
         return __gen_block_lambda_result_result
-    f(safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.l", l, [__gen_block_lambda_2], []))
+    f(safeds_runner.memoized_static_call("tests.generator.runnerIntegration.expressions.calls.main.l", l, [__gen_lambda_7], []))