feat: substitute type parameters when computing type of inherited mem…

…bers (#864)

Closes #863

### Summary of Changes

We now also substitute type parameters when computing the type for
inherited members in a member access. Example:

```
class C<T> {
    attr member: T
}

class D sub C<Int>

segment mySegment(p: D) {
    val a = p.member;
}
```

`a` now get the correct type `Int` (previously it was `T`).

packages/safe-ds-lang/src/language/typing/safe-ds-type-computer.ts

@@ -507,16 +507,22 @@ export class SafeDsTypeComputer {
  }
 
  const receiverType = this.computeType(node.receiver);
- const unsubstitutedResult = memberType.updateNullability(
- (receiverType.isNullable && node.isNullSafe) || memberType.isNullable,
- );
+ let result: Type = memberType;
 
- // Substitute type parameters
+ // Substitute type parameters (must also work for inherited members)
  if (receiverType instanceof ClassType) {
- return unsubstitutedResult.substituteTypeParameters(receiverType.substitutions);
- } else {
- return unsubstitutedResult;
+ const classContainingMember = getContainerOfType(node.member?.target.ref, isSdsClass);
+ const typeContainingMember = stream([receiverType], this.streamSupertypes(receiverType)).find(
+ (it) => it.declaration === classContainingMember,
+ );
+
+ if (typeContainingMember) {
+ result = result.substituteTypeParameters(typeContainingMember.substitutions);
+ }
  }
+
+ // Update nullability
+ return result.updateNullability((receiverType.isNullable && node.isNullSafe) || memberType.isNullable);
  }
 
  private computeTypeOfArithmeticPrefixOperation(node: SdsPrefixOperation): Type {

packages/safe-ds-lang/tests/resources/typing/expressions/member accesses/on class with type parameters/main.sdstest

@@ -6,9 +6,13 @@ class C<T> {
  @Pure fun method() -> r: T
 }
 
+class D sub C<Int>
+
 @Pure fun nullableC() -> result: C<Int>?
+@Pure fun nullableD() -> result: D?
 
-segment mySegment(p: C<Int>) {
+// Accessing own members
+segment mySegment1(p: C<Int>) {
  // $TEST$ serialization Int
  »p.nonNullableMember«;
  // $TEST$ serialization Int?
@@ -38,3 +42,35 @@ segment mySegment(p: C<Int>) {
  // $TEST$ serialization union<() -> (r: Int), literal<null>>
  »nullableC()?.method«;
 }
+
+// Accessing inherited members
+segment mySegment2(p: D) {
+ // $TEST$ serialization Int
+ »p.nonNullableMember«;
+ // $TEST$ serialization Int?
+ »p.nullableMember«;
+ // $TEST$ serialization () -> (r: Int)
+ »p.method«;
+
+ // $TEST$ serialization Int
+ »p?.nonNullableMember«;
+ // $TEST$ serialization Int?
+ »p?.nullableMember«;
+ // $TEST$ serialization () -> (r: Int)
+ »p?.method«;
+
+
+ // $TEST$ serialization Int
+ »nullableD().nonNullableMember«;
+ // $TEST$ serialization Int?
+ »nullableD().nullableMember«;
+ // $TEST$ serialization () -> (r: Int)
+ »nullableD().method«;
+
+ // $TEST$ serialization Int?
+ »nullableD()?.nonNullableMember«;
+ // $TEST$ serialization Int?
+ »nullableD()?.nullableMember«;
+ // $TEST$ serialization union<() -> (r: Int), literal<null>>
+ »nullableD()?.method«;
+}