Allow effects from outer scope in effect handler fields

1 files changed, 126 insertions, 0 deletions

diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java
index a0349098..d48eaf79 100644
--- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java
+++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java
@@ -313,4 +313,130 @@ public class TypeCheckerTryTests {
                 ))
         );
     }
+
+    @Test
+    public void whenEffectIsNotAllowedInExpressionScopeAndIsNotHandledEffectThenEffectIsNotAllowedInHandlerScope() {
+        var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEffect");
+        var unexpectedEffect = Effects.userDefined(NAMESPACE_NAME, "UnexpectedEffect");
+        var untyped = UntypedTryNode.builder()
+            .withHandledEffect(Untyped.typeLevelReference(handledEffect.name()))
+            .addHandlerField(
+                UntypedFunctionDefinitionNode.builder()
+                    .withName("effectField")
+                    .addStatement(Untyped.expressionStatement(
+                        UntypedCallNode.builder()
+                            .withReceiver(Untyped.reference("f"))
+                            .withHasEffects(true)
+                            .build()
+                    ))
+                    .build()
+            )
+            .build();
+        var context = TypeCheckerContext.EMPTY
+            .enterFunction(
+                P.map(
+                    Map.entry(handledEffect.name(), Variable.defined(Types.effectType(handledEffect), VariableType.CONSTANT)),
+                    Map.entry("f", Variable.defined(FunctionType.builder().withEffect(unexpectedEffect).build(), VariableType.VAL))
+                ),
+                Effects.NONE,
+                Optional.empty()
+            )
+            .addUserDefinedEffectInfo(
+                handledEffect,
+                UserDefinedEffectInfo.builder()
+                    .addField("effectField", FunctionType.builder().withReturnType(Types.UNIT).build())
+                    .build()
+            )
+            .addUserDefinedEffectInfo(unexpectedEffect, UserDefinedEffectInfo.builder().build());
+
+        var error = assertThrows(
+            UnexpectedEffectError.class,
+            () -> typeCheckExpression(untyped, context)
+        );
+
+        assertThat(error.allowed(), equalTo(Effects.NONE));
+        assertThat(error.actual(), equalTo(unexpectedEffect));
+    }
+
+    @Test
+    public void effectsAllowedInExpressionScopeAreAllowedInHandlerScope() {
+        var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEffect");
+        var allowedEffect = Effects.userDefined(NAMESPACE_NAME, "AllowedEffect");
+        var untyped = UntypedTryNode.builder()
+            .withHandledEffect(Untyped.typeLevelReference(handledEffect.name()))
+            .addHandlerField(
+                UntypedFunctionDefinitionNode.builder()
+                    .withName("effectField")
+                    .addStatement(Untyped.expressionStatement(
+                        UntypedCallNode.builder()
+                            .withReceiver(Untyped.reference("f"))
+                            .withHasEffects(true)
+                            .build()
+                    ))
+                    .build()
+            )
+            .build();
+        var context = TypeCheckerContext.EMPTY
+            .enterFunction(
+                P.map(
+                    Map.entry(handledEffect.name(), Variable.defined(Types.effectType(handledEffect), VariableType.CONSTANT)),
+                    Map.entry("f", Variable.defined(FunctionType.builder().withEffect(allowedEffect).build(), VariableType.VAL))
+                ),
+                allowedEffect,
+                Optional.empty()
+            )
+            .addUserDefinedEffectInfo(
+                handledEffect,
+                UserDefinedEffectInfo.builder()
+                    .addField("effectField", FunctionType.builder().withReturnType(Types.UNIT).build())
+                    .build()
+            )
+            .addUserDefinedEffectInfo(allowedEffect, UserDefinedEffectInfo.builder().build());
+
+        var result = typeCheckExpression(untyped, context);
+
+        assertThat(result.value(), isTypedTryNode());
+    }
+
+    @Test
+    public void handledEffectIsNotAllowedInHandlerScope() {
+        var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEffect");
+        var untyped = UntypedTryNode.builder()
+            .withHandledEffect(Untyped.typeLevelReference(handledEffect.name()))
+            .addHandlerField(
+                UntypedFunctionDefinitionNode.builder()
+                    .withName("effectField")
+                    .addStatement(Untyped.expressionStatement(
+                        UntypedCallNode.builder()
+                            .withReceiver(Untyped.reference("f"))
+                            .withHasEffects(true)
+                            .build()
+                    ))
+                    .build()
+            )
+            .build();
+        var context = TypeCheckerContext.EMPTY
+            .enterFunction(
+                P.map(
+                    Map.entry(handledEffect.name(), Variable.defined(Types.effectType(handledEffect), VariableType.CONSTANT)),
+                    Map.entry("f", Variable.defined(FunctionType.builder().withEffect(handledEffect).build(), VariableType.VAL))
+                ),
+                Effects.NONE,
+                Optional.empty()
+            )
+            .addUserDefinedEffectInfo(
+                handledEffect,
+                UserDefinedEffectInfo.builder()
+                    .addField("effectField", FunctionType.builder().withReturnType(Types.UNIT).build())
+                    .build()
+            );
+
+        var error = assertThrows(
+            UnexpectedEffectError.class,
+            () -> typeCheckExpression(untyped, context)
+        );
+
+        assertThat(error.allowed(), equalTo(Effects.NONE));
+        assertThat(error.actual(), equalTo(handledEffect));
+    }
 }