feat: scoping for parameters of enum variants

src/language/scoping/safe-ds-scope-provider.ts

@@ -218,8 +218,8 @@ export class SafeDsScopeProvider extends DefaultScopeProvider {
             // Scopes.scopeFor(members, Scopes.scopeFor(superTypeMembers, resultScope))
             return this.createScopeForNodes(ownInstanceMembers, resultScope);
         } else if (receiverType instanceof EnumVariantType) {
-            // Scopes.scopeFor(type.sdsEnumVariant.parametersOrEmpty())
-            return resultScope;
+            const parameters = parametersOrEmpty(receiverType.sdsEnumVariant);
+            return this.createScopeForNodes(parameters, resultScope);
         }
 
         return resultScope;

tests/resources/scoping/member accesses/to parameter of enum variants/main.sdstest

@@ -0,0 +1,45 @@
+package tests.scoping.memberAccesses.toParametersOfEnumVariants
+
+enum MyEnum {
+    MyEnumVariant(
+        // $TEST$ target param
+        »param«: Int,
+
+        // $TEST$ target redeclared
+        »redeclared«: Int,
+        redeclared: Int,
+    )
+
+    MyOtherEnumVariant
+}
+
+enum MyOtherEnum {
+    MyEnumVariant
+}
+
+pipeline myPipeline {
+    // $TEST$ references param
+    MyEnum.MyEnumVariant().»param«;
+
+    // $TEST$ references redeclared
+    MyEnum.MyEnumVariant().»redeclared«;
+
+
+    // $TEST$ unresolved
+    MyOtherEnum.MyEnumVariant.»param«;
+
+    // $TEST$ unresolved
+    MyEnum.MyOtherEnumVariant().»param«;
+
+    // $TEST$ unresolved
+    MyOtherEnum.MyEnumVariant().»param«;
+
+    // $TEST$ unresolved
+    MyEnum.MyEnumVariant().»unresolved«;
+
+    // $TEST$ unresolved
+    MyEnum.unresolved().»param«;
+
+    // $TEST$ unresolved
+    unresolved.MyEnumVariant().»param«;
+}

tests/resources/scoping/member accesses/to results/of block lambdas (matching member)/main.sdstest

@@ -5,11 +5,23 @@ class MyClass() {
     attr »result«: Int
 }
 
+enum MyEnum {
+    // $TEST$ target MyEnum_result
+    MyEnumVariant(»result«: Int)
+}
+
 pipeline myPipeline {
-    val lambdaWithOneResultWithIdenticalMember = () {
+    val f1 = () {
         yield result = MyClass();
     };
 
+    val f2 = () {
+        yield result = MyEnum.MyEnumVariant(0);
+    };
+
     // $TEST$ references MyClass_result
-    lambdaWithOneResultWithIdenticalMember().»result«;
+    f1().»result«;
+
+    // $TEST$ references MyEnum_result
+    f2().»result«;
 }

tests/resources/scoping/member accesses/to results/of callable types (matching member)/main.sdstest

@@ -5,9 +5,19 @@ class MyClass() {
     attr »result«: Int
 }
 
+enum MyEnum {
+    // $TEST$ target MyEnum_result
+    MyEnumVariant(»result«: Int)
+}
+
 segment mySegment(
-    callableWithIdenticalMember: () -> result: MyClass
+    f1: () -> result: MyClass,
+    f2: () -> result: MyEnum.MyEnumVariant,
 ) {
+
     // $TEST$ references MyClass_result
-    callableWithIdenticalMember().»result«;
+    f1().»result«;
+
+    // $TEST$ references MyEnum_result
+    f2().»result«;
 }

tests/resources/scoping/member accesses/to results/of functions (matching member)/main.sdstest

@@ -5,9 +5,18 @@ class MyClass() {
     attr »result«: Int
 }
 
-fun functionWithOneResultWithIdenticalMember() -> result: MyClass
+enum MyEnum {
+    // $TEST$ target MyEnum_result
+    MyEnumVariant(»result«: Int)
+}
+
+fun f1() -> result: MyClass
+fun f2() -> result: MyEnum.MyEnumVariant
 
 pipeline myPipeline {
     // $TEST$ references MyClass_result
-    functionWithOneResultWithIdenticalMember().»result«;
+    f1().»result«;
+
+    // $TEST$ references MyEnum_result
+    f2().»result«;
 }

tests/resources/scoping/member accesses/to results/of segments (matching member)/main.sdstest

@@ -5,9 +5,18 @@ class MyClass() {
     attr »result«: Int
 }
 
-segment segmentWithOneResultWithIdenticalMember() -> result: MyClass {}
+enum MyEnum {
+    // $TEST$ target MyEnum_result
+    MyEnumVariant(»result«: Int)
+}
+
+segment s1() -> result: MyClass {}
+segment s2() -> result: MyEnum.MyEnumVariant {}
 
 pipeline myPipeline {
     // $TEST$ references MyClass_result
-    segmentWithOneResultWithIdenticalMember().»result«;
+    s1().»result«;
+
+    // $TEST$ references MyEnum_result
+    s2().»result«;
 }