From 23bc783e4c0eea019d47f1b69d9d8a74adb15326 Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Sun, 5 Nov 2023 19:33:28 +0000 Subject: Add handled effect to try body effects --- .../typechecker/TypeCheckerIsSubEffectTests.java | 54 ++++++++++++++++++++++ .../compiler/typechecker/TypeCheckerTryTests.java | 33 +++++++++++-- .../shedlang/compiler/types/EffectUnionTests.java | 28 +++++++++++ 3 files changed, 112 insertions(+), 3 deletions(-) create mode 100644 src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java create mode 100644 src/test/java/org/shedlang/compiler/types/EffectUnionTests.java (limited to 'src/test/java') diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java new file mode 100644 index 00000000..72e0fa32 --- /dev/null +++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubEffectTests.java @@ -0,0 +1,54 @@ +package org.shedlang.compiler.typechecker; + +import org.junit.jupiter.api.Test; +import org.shedlang.compiler.types.Effects; +import org.shedlang.compiler.types.NamespaceName; + +import static org.shedlang.compiler.typechecker.TypeCheckerSubTyping.isSubEffect; +import static org.zwobble.precisely.AssertThat.assertThat; +import static org.zwobble.precisely.Matchers.equalTo; + +public class TypeCheckerIsSubEffectTests { + public static final NamespaceName NAMESPACE_NAME = NamespaceName.of("Example", "Project"); + + @Test + public void effectsAreSubEffectsOfThemselves() { + var effect = Effects.userDefined(NAMESPACE_NAME, "Effect"); + var context = TypeCheckerContext.EMPTY; + + assertThat(isSubEffect(Effects.IO, Effects.IO, context), equalTo(true)); + assertThat(isSubEffect(Effects.NONE, Effects.NONE, context), equalTo(true)); + assertThat(isSubEffect(effect, effect, context), equalTo(true)); + } + + @Test + public void unrelatedEffectsAreNotSubEffects() { + var effect1 = Effects.userDefined(NAMESPACE_NAME, "Effect1"); + var effect2 = Effects.userDefined(NAMESPACE_NAME, "Effect2"); + var context = TypeCheckerContext.EMPTY; + + assertThat(isSubEffect(effect1, effect2, context), equalTo(false)); + assertThat(isSubEffect(effect1, Effects.IO, context), equalTo(false)); + assertThat(isSubEffect(Effects.IO, effect2, context), equalTo(false)); + } + + @Test + public void noneEffectIsSubEffectOfAllEffects() { + var effect = Effects.userDefined(NAMESPACE_NAME, "Effect"); + var context = TypeCheckerContext.EMPTY; + + assertThat(isSubEffect(Effects.NONE, effect, context), equalTo(true)); + assertThat(isSubEffect(Effects.NONE, Effects.IO, context), equalTo(true)); + assertThat(isSubEffect(Effects.NONE, Effects.NONE, context), equalTo(true)); + } + + @Test + public void noneEffectIsOnlySuperEffectOfItself() { + var effect = Effects.userDefined(NAMESPACE_NAME, "Effect"); + var context = TypeCheckerContext.EMPTY; + + assertThat(isSubEffect(effect, Effects.NONE, context), equalTo(false)); + assertThat(isSubEffect(Effects.IO, Effects.NONE, context), equalTo(false)); + assertThat(isSubEffect(Effects.NONE, Effects.NONE, context), equalTo(true)); + } +} diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java index 566a93ee..9224c8ff 100644 --- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java +++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerTryTests.java @@ -49,7 +49,7 @@ public class TypeCheckerTryTests { @Test public void whenEffectIsNotAllowedInExpressionScopeAndIsNotHandledEffectThenEffectIsNotAllowedInBodyScope() { - var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEmpty"); + var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEffect"); var unexpectedEffect = Effects.userDefined(NAMESPACE_NAME, "UnexpectedEffect"); var untyped = UntypedTryNode.builder() .addBodyStatement(Untyped.expressionStatement( @@ -75,13 +75,13 @@ public class TypeCheckerTryTests { () -> typeCheckExpression(untyped, context) ); - assertThat(error.allowed(), equalTo(Effects.NONE)); + assertThat(error.allowed(), equalTo(handledEffect)); assertThat(error.actual(), equalTo(unexpectedEffect)); } @Test public void effectsAllowedInExpressionScopeAreAllowedInBodyScope() { - var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEmpty"); + var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEffect"); var allowedEffect = Effects.userDefined(NAMESPACE_NAME, "AllowedEffect"); var untyped = UntypedTryNode.builder() .addBodyStatement(Untyped.expressionStatement( @@ -106,4 +106,31 @@ public class TypeCheckerTryTests { assertThat(result.value(), isTypedTryNode()); } + + @Test + public void handledEffectIsAllowedInBodyScope() { + var handledEffect = Effects.userDefined(NAMESPACE_NAME, "HandledEffect"); + var untyped = UntypedTryNode.builder() + .addBodyStatement(Untyped.expressionStatement( + UntypedCallNode.builder() + .withReceiver(Untyped.reference("f")) + .withHasEffects(true) + .build() + )) + .withHandledEffect(Untyped.typeLevelReference(handledEffect.name())) + .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() + ); + + var result = typeCheckExpression(untyped, context); + + assertThat(result.value(), isTypedTryNode()); + } } diff --git a/src/test/java/org/shedlang/compiler/types/EffectUnionTests.java b/src/test/java/org/shedlang/compiler/types/EffectUnionTests.java new file mode 100644 index 00000000..9825a354 --- /dev/null +++ b/src/test/java/org/shedlang/compiler/types/EffectUnionTests.java @@ -0,0 +1,28 @@ +package org.shedlang.compiler.types; + +import org.junit.jupiter.api.Test; + +import static org.zwobble.precisely.AssertThat.assertThat; +import static org.zwobble.precisely.Matchers.equalTo; + +public class EffectUnionTests { + @Test + public void unionOfNoneAndOtherTypeIsOtherType() { + var effect = Effects.userDefined(NamespaceName.of("Example"), "Effect"); + + assertThat(Effects.union(effect, Effects.NONE), equalTo(effect)); + assertThat(Effects.union(Effects.NONE, effect), equalTo(effect)); + assertThat(Effects.union(Effects.NONE, Effects.NONE), equalTo(Effects.NONE)); + } + + @Test + public void effectUnionDescriptionIsBarSeparatedConstituentEffects() { + var effect1 = Effects.userDefined(NamespaceName.of("Example1"), "Effect1"); + var effect2 = Effects.userDefined(NamespaceName.of("Example2"), "Effect2"); + var union = Effects.union(effect1, effect2); + + var result = union.describe(); + + assertThat(result, equalTo("Example1.Effect1 | Example2.Effect2")); + } +} -- cgit v1.2.3