fix: substitute type parameters for lambda parameters (#1050)

Closes #1047 ### Summary of Changes Type of lambda parameters can be inferred from the context. Previously, however, type parameter types that were contained in the inferred type were not substituted. Now, they also get inferred from the context.
Safe-DS · Apr 15, 2024 · 46145dd · 46145dd
1 parent db0c5d7
commit 46145dd
Show file tree

Hide file tree

Showing 7 changed files with 307 additions and 145 deletions.
diff --git a/packages/safe-ds-lang/src/language/typing/safe-ds-type-computer.ts b/packages/safe-ds-lang/src/language/typing/safe-ds-type-computer.ts
diff --git a/...ions/parameters/of block lambdas/that are passed as arguments/with type parameters.sdsdev b/...ions/parameters/of block lambdas/that are passed as arguments/with type parameters.sdsdev
@@ -0,0 +1,22 @@
+package tests.typing.declarations.parameters.ofBlockLambdas.thatArePassedAsArguments.withTypeParameters
+
+class MySuperclass<T> {
+    @Pure fun myInheritedMethod(callback: (p: T) -> ())
+}
+
+class MyClass<T>(param: T) sub MySuperclass<T> {
+    @Pure fun myMethod(callback: (p: T) -> ())
+}
+
+@Pure fun myFunction<T>(p: T, callback: (p: T) -> ())
+
+segment mySegment() {
+    // $TEST$ serialization literal<1>
+    MyClass(1).myMethod((»p«) {});
+
+    // $TEST$ serialization literal<1>
+    MyClass(1).myInheritedMethod((»p«) {});
+
+    // $TEST$ serialization literal<1>
+    myFunction(1, (»p«) {});
+}
diff --git a/...parameters/of expression lambdas/that are passed as arguments/with type parameters.sdsdev b/...parameters/of expression lambdas/that are passed as arguments/with type parameters.sdsdev
@@ -0,0 +1,22 @@
+package tests.typing.declarations.parameters.ofExpressionLambdas.thatArePassedAsArguments.withTypeParameters
+
+class MySuperclass<T> {
+    @Pure fun myInheritedMethod(callback: (p: T) -> ())
+}
+
+class MyClass<T>(param: T) sub MySuperclass<T> {
+    @Pure fun myMethod(callback: (p: T) -> ())
+}
+
+@Pure fun myFunction<T>(p: T, callback: (p: T) -> ())
+
+segment mySegment() {
+    // $TEST$ serialization literal<1>
+    MyClass(1).myMethod((»p«) -> "");
+
+    // $TEST$ serialization literal<1>
+    MyClass(1).myInheritedMethod((»p«) -> "");
+
+    // $TEST$ serialization literal<1>
+    myFunction(1, (»p«) -> "");
+}
diff --git a/...tests/resources/typing/expressions/block lambdas/that are passed as arguments/main.sdsdev b/...tests/resources/typing/expressions/block lambdas/that are passed as arguments/main.sdsdev
@@ -1,9 +1,9 @@
 package tests.typing.expressions.blockLambdas.thatArePassedAsArguments
 
-fun higherOrderFunction1(param: (p: String) -> (r: Int, s: String))
-fun higherOrderFunction2(param: () -> ())
-fun normalFunction(param: Int)
-fun parameterlessFunction()
+@Pure fun higherOrderFunction1(param: (p: String) -> (r: Int, s: String))
+@Pure fun higherOrderFunction2(param: () -> ())
+@Pure fun normalFunction(param: Int)
+@Pure fun parameterlessFunction()
 
 segment mySegment() {
     // $TEST$ serialization (p: String) -> (r: literal<1>, s: literal<"">)

diff --git a/...typing/expressions/block lambdas/that are passed as arguments/with type parameters.sdsdev b/...typing/expressions/block lambdas/that are passed as arguments/with type parameters.sdsdev
@@ -0,0 +1,28 @@
+package tests.typing.expressions.blockLambdas.thatArePassedAsArguments.withTypeParameters
+
+class MySuperclass<T> {
+    @Pure fun myInheritedMethod(callback: (p: T) -> ())
+}
+
+class MyClass<T>(param: T) sub MySuperclass<T> {
+    @Pure fun myMethod(callback: (p: T) -> ())
+}
+
+@Pure fun myFunction<T>(p: T, id: (p: T) -> (r: T))
+
+segment mySegment() {
+    // $TEST$ serialization (p: literal<1>) -> (r: literal<1>)
+    MyClass(1).myMethod(»(p) {
+        yield r = p;
+    }«);
+
+    // $TEST$ serialization (p: literal<1>) -> (r: literal<1>)
+    MyClass(1).myInheritedMethod(»(p) {
+        yield r = p;
+    }«);
+
+    // $TEST$ serialization (p: literal<1>) -> (r: literal<1>)
+    myFunction(1, »(p) {
+        yield r = p;
+    }«);
+}
diff --git a/.../resources/typing/expressions/expression lambdas/that are passed as arguments/main.sdsdev b/.../resources/typing/expressions/expression lambdas/that are passed as arguments/main.sdsdev
@@ -1,9 +1,9 @@
 package tests.typing.expressions.expressionLambdas.thatArePassedAsArguments
 
-fun higherOrderFunction1(param: (p: String) -> (r: Int))
-fun higherOrderFunction2(param: () -> ())
-fun normalFunction(param: Int)
-fun parameterlessFunction()
+@Pure fun higherOrderFunction1(param: (p: String) -> (r: Int))
+@Pure fun higherOrderFunction2(param: () -> ())
+@Pure fun normalFunction(param: Int)
+@Pure fun parameterlessFunction()
 
 segment mySegment() {
     // $TEST$ serialization (p: String) -> (result: literal<1>)

diff --git a/...g/expressions/expression lambdas/that are passed as arguments/with type parameters.sdsdev b/...g/expressions/expression lambdas/that are passed as arguments/with type parameters.sdsdev
@@ -0,0 +1,22 @@
+package tests.typing.expressions.expressionLambdas.thatArePassedAsArguments.withTypeParameters
+
+class MySuperclass<T> {
+    @Pure fun myInheritedMethod(callback: (p: T) -> ())
+}
+
+class MyClass<T>(param: T) sub MySuperclass<T> {
+    @Pure fun myMethod(callback: (p: T) -> ())
+}
+
+@Pure fun myFunction<T>(p: T, id: (p: T) -> (r: T))
+
+segment mySegment() {
+    // $TEST$ serialization (p: literal<1>) -> (result: literal<1>)
+    MyClass(1).myMethod(»(p) -> p«);
+
+    // $TEST$ serialization (p: literal<1>) -> (result: literal<1>)
+    MyClass(1).myInheritedMethod(»(p) -> p«);
+
+    // $TEST$ serialization (p: literal<1>) -> (result: literal<1>)
+    myFunction(1, »(p) -> p«);
+}