From 98f33d0f843c88c404b525134986393a1b1569cb Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Wed, 3 Jan 2024 22:07:36 +0000 Subject: Introduce base types for struct types and sum types respectively --- .../org/shedlang/compiler/ast/typed/Typed.java | 4 +- .../compiler/ast/typed/TypedNodeMatchers.java | 4 +- .../typed/TypedStructDefinitionNodeMatcher.java | 4 +- .../compiler/shid/ShidCodeGenWhenTests.java | 5 +- .../shedlang/compiler/shid/instructions/Shid.java | 8 +-- .../compiler/shid/instructions/ShidMatchers.java | 6 +-- .../typechecker/TypeCheckerIsSubTypeTests.java | 36 ++++++------- .../TypeCheckerSumTypeDefinitionTests.java | 13 +++-- .../compiler/typechecker/TypeCheckerWhenTests.java | 62 +++++++++++----------- .../compiler/types/ConstructedTypeTests.java | 2 +- .../org/shedlang/compiler/types/TypeMatchers.java | 4 +- .../compiler/types/TypeSubstitutionTests.java | 4 +- 12 files changed, 75 insertions(+), 77 deletions(-) (limited to 'src/test/java') diff --git a/src/test/java/org/shedlang/compiler/ast/typed/Typed.java b/src/test/java/org/shedlang/compiler/ast/typed/Typed.java index b501007e..bfa2564b 100644 --- a/src/test/java/org/shedlang/compiler/ast/typed/Typed.java +++ b/src/test/java/org/shedlang/compiler/ast/typed/Typed.java @@ -225,7 +225,7 @@ public class Typed { return new TypedStructFieldDefinitionNode(name, type, Sources.NULL); } - public static TypedSumTypeDefinitionNode sumTypeDefinition(SumType sumType) { + public static TypedSumTypeDefinitionNode sumTypeDefinition(SimpleSumType sumType) { return new TypedSumTypeDefinitionNode( TypeOrConstructor.type(sumType), Sources.NULL @@ -296,7 +296,7 @@ public class Typed { } public static TypedWhenCaseNode whenCase( - SumVariant caseType, + StructType caseType, TypedBlockNode body ) { return new TypedWhenCaseNode(caseType, body, Sources.NULL); diff --git a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java index f01c82c1..2b63f11c 100644 --- a/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java +++ b/src/test/java/org/shedlang/compiler/ast/typed/TypedNodeMatchers.java @@ -302,7 +302,7 @@ public class TypedNodeMatchers { } public static Matcher isTypedSumTypeDefinitionNode( - Matcher> typeOrConstructor + Matcher> typeOrConstructor ) { return instanceOf( TypedSumTypeDefinitionNode.class, @@ -421,7 +421,7 @@ public class TypedNodeMatchers { } public static Matcher isTypedWhenCaseNode( - Matcher caseType, + Matcher caseType, Matcher body ) { return allOf( diff --git a/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java b/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java index 6bf0dcb9..aeb8d3ee 100644 --- a/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java +++ b/src/test/java/org/shedlang/compiler/ast/typed/TypedStructDefinitionNodeMatcher.java @@ -2,7 +2,7 @@ package org.shedlang.compiler.ast.typed; import org.pcollections.PVector; import org.shedlang.compiler.testing.MatcherBuilder; -import org.shedlang.compiler.types.StructType; +import org.shedlang.compiler.types.SimpleStructType; import org.shedlang.compiler.types.TypeConstructor; import org.shedlang.compiler.util.P; import org.zwobble.precisely.Matcher; @@ -34,7 +34,7 @@ public class TypedStructDefinitionNodeMatcher extends MatcherBuilder< return new TypedStructDefinitionNodeMatcher(submatchers); } - public TypedStructDefinitionNodeMatcher withType(Matcher type) { + public TypedStructDefinitionNodeMatcher withType(Matcher type) { return with(has( "typeOrConstructor", x -> x.typeOrConstructor(), diff --git a/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java b/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java index e9c243f6..c13b0e13 100644 --- a/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java +++ b/src/test/java/org/shedlang/compiler/shid/ShidCodeGenWhenTests.java @@ -3,7 +3,6 @@ package org.shedlang.compiler.shid; import org.junit.jupiter.api.Test; import org.shedlang.compiler.ast.typed.Typed; import org.shedlang.compiler.types.NamespaceName; -import org.shedlang.compiler.types.SumVariant; import org.shedlang.compiler.types.Types; import java.util.List; @@ -21,13 +20,13 @@ public class ShidCodeGenWhenTests { Typed.reference("x"), List.of( Typed.whenCase( - SumVariant.struct(Types.struct(NAMESPACE_NAME, "A")), + Types.struct(NAMESPACE_NAME, "A"), Typed.block(List.of( Typed.blockReturn(Typed.stringLiteral("a")) )) ), Typed.whenCase( - SumVariant.struct(Types.struct(NAMESPACE_NAME, "B")), + Types.struct(NAMESPACE_NAME, "B"), Typed.block(List.of( Typed.blockReturn(Typed.stringLiteral("b")) )) diff --git a/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java b/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java index 11eaa62d..ee78a3e3 100644 --- a/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java +++ b/src/test/java/org/shedlang/compiler/shid/instructions/Shid.java @@ -2,7 +2,7 @@ package org.shedlang.compiler.shid.instructions; import org.shedlang.compiler.sources.Sources; import org.shedlang.compiler.types.NamespaceName; -import org.shedlang.compiler.types.StructType; +import org.shedlang.compiler.types.SimpleStructType; import org.shedlang.compiler.types.UserDefinedEffect; import java.math.BigInteger; @@ -29,7 +29,7 @@ public class Shid { } public static ShidInstruction defineStruct( - StructType type, + SimpleStructType type, List fields ) { return new ShidDefineStruct( @@ -63,7 +63,7 @@ public class Shid { ); } - public static ShidInstruction fieldLoad(StructType type, String fieldName) { + public static ShidInstruction fieldLoad(SimpleStructType type, String fieldName) { return new ShidFieldLoad( new ShidFieldLoad.Receiver.Struct(type), fieldName, @@ -172,7 +172,7 @@ public class Shid { } public static ShidSwitch.Case switchCase( - StructType type, + SimpleStructType type, ShidBlock body ) { return new ShidSwitch.Case(type, body, Sources.NULL); diff --git a/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java b/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java index d1dc4130..51736459 100644 --- a/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java +++ b/src/test/java/org/shedlang/compiler/shid/instructions/ShidMatchers.java @@ -1,7 +1,7 @@ package org.shedlang.compiler.shid.instructions; import org.shedlang.compiler.types.NamespaceName; -import org.shedlang.compiler.types.StructType; +import org.shedlang.compiler.types.SimpleStructType; import org.shedlang.compiler.types.UserDefinedEffect; import org.zwobble.precisely.Matcher; @@ -67,7 +67,7 @@ public class ShidMatchers { } public static Matcher isShidFieldLoad( - StructType receiverType, + SimpleStructType receiverType, String fieldName ) { return isShidFieldLoad( @@ -207,7 +207,7 @@ public class ShidMatchers { } public static Matcher isShidSwitchCase( - StructType caseType, + SimpleStructType caseType, Matcher body ) { return allOf( diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java index d86e0ed2..580be580 100644 --- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java +++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerIsSubTypeTests.java @@ -26,8 +26,8 @@ public class TypeCheckerIsSubTypeTests { assertThat(isSubType(Types.INT, Types.INT, typeInfos), equalTo(true)); assertThat( isSubType( - new StructType(namespaceName, "X"), - new StructType(namespaceName, "X"), + new SimpleStructType(namespaceName, "X"), + new SimpleStructType(namespaceName, "X"), typeInfos ), equalTo(true) @@ -42,8 +42,8 @@ public class TypeCheckerIsSubTypeTests { assertThat(isSubType(Types.INT, Types.STRING, typeInfos), equalTo(false)); assertThat( isSubType( - new StructType(namespaceName, "X"), - new StructType(namespaceName, "Y"), + new SimpleStructType(namespaceName, "X"), + new SimpleStructType(namespaceName, "Y"), typeInfos ), equalTo(false) @@ -60,7 +60,7 @@ public class TypeCheckerIsSubTypeTests { assertThat(isSubType(Types.INT, Types.TOP, typeInfos), equalTo(true)); assertThat( isSubType( - new StructType(namespaceName, "X"), + new SimpleStructType(namespaceName, "X"), Types.TOP, typeInfos ), @@ -77,7 +77,7 @@ public class TypeCheckerIsSubTypeTests { assertThat( isSubType( Types.TOP, - new StructType(namespaceName, "X"), + new SimpleStructType(namespaceName, "X"), typeInfos ), equalTo(false) @@ -95,7 +95,7 @@ public class TypeCheckerIsSubTypeTests { assertThat( isSubType( Types.BOTTOM, - new StructType(namespaceName, "X"), + new SimpleStructType(namespaceName, "X"), typeInfos ), equalTo(true) @@ -110,7 +110,7 @@ public class TypeCheckerIsSubTypeTests { assertThat(isSubType(Types.INT, Types.BOTTOM, typeInfos), equalTo(false)); assertThat( isSubType( - new StructType(namespaceName, "X"), + new SimpleStructType(namespaceName, "X"), Types.BOTTOM, typeInfos ), @@ -171,8 +171,8 @@ public class TypeCheckerIsSubTypeTests { var variantType2 = Types.struct(namespaceName, "Variant2"); var typeInfos = TypeInfos.EMPTY .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet( - SumVariant.struct(variantType1), - SumVariant.struct(variantType2) + variantType1, + variantType2 ))); assertThat(isSubType(variantType1, sumType, typeInfos), equalTo(true)); @@ -187,8 +187,8 @@ public class TypeCheckerIsSubTypeTests { var variantType2 = Types.struct(namespaceName, "Variant2"); var typeInfos = TypeInfos.EMPTY .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet( - SumVariant.struct(variantType1), - SumVariant.struct(variantType2) + variantType1, + variantType2 ))); assertThat(isSubType(sumType, variantType1, typeInfos), equalTo(false)); @@ -211,8 +211,8 @@ public class TypeCheckerIsSubTypeTests { var variantType2 = Types.struct(namespaceName, "Variant2"); var typeInfos = TypeInfos.EMPTY .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet( - SumVariant.struct(variantType1), - SumVariant.struct(variantType2) + variantType1, + variantType2 ))); assertThat(isSubType(variantType1, constructedSumType, typeInfos), equalTo(true)); @@ -243,8 +243,8 @@ public class TypeCheckerIsSubTypeTests { var variantType2 = Types.struct(namespaceName, "Variant2"); var typeInfos = TypeInfos.EMPTY .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet( - SumVariant.constructedStruct(constructedVariantType1), - SumVariant.struct(variantType2) + constructedVariantType1, + variantType2 ))); assertThat(isSubType(constructedVariantType1, constructedSumType, typeInfos), equalTo(true)); @@ -274,8 +274,8 @@ public class TypeCheckerIsSubTypeTests { var variantType2 = Types.struct(namespaceName, "Variant2"); var typeInfos = TypeInfos.EMPTY .addSumTypeInfo(sumType, new SumTypeInfo(P.orderedSet( - SumVariant.struct(variantType1), - SumVariant.struct(variantType2) + variantType1, + variantType2 ))); assertThat(isSubType(constructedSumType, variantType1, typeInfos), equalTo(false)); diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java index a605e029..0585625a 100644 --- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java +++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerSumTypeDefinitionTests.java @@ -6,7 +6,6 @@ import org.shedlang.compiler.ast.untyped.UntypedSumTypeDefinitionNode; import org.shedlang.compiler.typechecker.errors.CannotDefineSumTypeOutsideOfNamespaceError; import org.shedlang.compiler.typechecker.errors.VariantTypeIsNotStructError; import org.shedlang.compiler.types.NamespaceName; -import org.shedlang.compiler.types.SumVariant; import org.shedlang.compiler.types.TypeParam; import org.shedlang.compiler.types.Types; import org.shedlang.compiler.util.P; @@ -157,8 +156,8 @@ public class TypeCheckerSumTypeDefinitionTests { assertThat( sumTypeInfo, has("variants", x -> x.variants(), isSequence( - equalTo(SumVariant.struct(variantType1)), - equalTo(SumVariant.struct(variantType2)) + equalTo(variantType1), + equalTo(variantType2) )) ); } @@ -227,20 +226,20 @@ public class TypeCheckerSumTypeDefinitionTests { assertThat( sumTypeInfo, has("variants", x -> x.variants(), isSequence( - equalTo(SumVariant.constructedStruct(Types.constructedStructType( + equalTo(Types.constructedStructType( variantTypeConstructor1, List.of(TypeParam.forSumType( Types.sum(NAMESPACE_NAME, "ExampleSumType"), "T1" )) - ))), - equalTo(SumVariant.constructedStruct(Types.constructedStructType( + )), + equalTo(Types.constructedStructType( variantTypeConstructor2, List.of(TypeParam.forSumType( Types.sum(NAMESPACE_NAME, "ExampleSumType"), "T2" )) - ))) + )) )) ); } diff --git a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java index 0db2546f..107bc9c4 100644 --- a/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java +++ b/src/test/java/org/shedlang/compiler/typechecker/TypeCheckerWhenTests.java @@ -20,9 +20,9 @@ import static org.zwobble.precisely.Matchers.*; public class TypeCheckerWhenTests { private static final NamespaceName NAMESPACE_NAME = NamespaceName.of("Example", "Project"); - private static final SumType SUM_TYPE = Types.sum(NAMESPACE_NAME, "SumType"); - private static final StructType VARIANT_TYPE_1 = Types.struct(NAMESPACE_NAME, "Variant1"); - private static final StructType VARIANT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Variant2"); + private static final SimpleSumType SUM_TYPE = Types.sum(NAMESPACE_NAME, "SumType"); + private static final SimpleStructType VARIANT_TYPE_1 = Types.struct(NAMESPACE_NAME, "Variant1"); + private static final SimpleStructType VARIANT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Variant2"); @Test public void whenExpressionIsNotInstanceOfSumTypeThenErrorIsThrown() { @@ -58,8 +58,8 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.struct(VARIANT_TYPE_1), - SumVariant.struct(VARIANT_TYPE_2) + VARIANT_TYPE_1, + VARIANT_TYPE_2 ))) .enterGlobal(P.map( Map.entry("x", SUM_TYPE), @@ -72,7 +72,7 @@ public class TypeCheckerWhenTests { () -> typeCheckExpression(untyped, context) ); - assertThat(error.unhandledVariant(), equalTo(SumVariant.struct(VARIANT_TYPE_2))); + assertThat(error.unhandledVariant(), equalTo(VARIANT_TYPE_2)); } @Test @@ -97,7 +97,7 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.struct(VARIANT_TYPE_1) + VARIANT_TYPE_1 ))) .enterGlobal(P.map( Map.entry("x", SUM_TYPE), @@ -134,7 +134,7 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.struct(VARIANT_TYPE_1) + VARIANT_TYPE_1 ))) .enterGlobal(P.map( Map.entry("x", SUM_TYPE), @@ -170,8 +170,8 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.struct(VARIANT_TYPE_1), - SumVariant.struct(VARIANT_TYPE_2) + VARIANT_TYPE_1, + VARIANT_TYPE_2 ))) .enterGlobal(P.map( Map.entry("x", SUM_TYPE), @@ -185,13 +185,13 @@ public class TypeCheckerWhenTests { isTypedReferenceNode("x", SUM_TYPE), isSequence( isTypedWhenCaseNode( - equalTo(SumVariant.struct(VARIANT_TYPE_1)), + equalTo(VARIANT_TYPE_1), isTypedBlockNode(isSequence( isTypedBlockReturnNode(isTypedStringLiteralNode("a")) )) ), isTypedWhenCaseNode( - equalTo(SumVariant.struct(VARIANT_TYPE_2)), + equalTo(VARIANT_TYPE_2), isTypedBlockNode(isSequence( isTypedBlockReturnNode(isTypedStringLiteralNode("b")) )) @@ -232,8 +232,8 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.constructedStruct(constructedVariantType1), - SumVariant.struct(VARIANT_TYPE_2) + constructedVariantType1, + VARIANT_TYPE_2 ))) .enterGlobal(P.map( Map.entry("String", Types.metaType(Types.STRING)), @@ -248,13 +248,13 @@ public class TypeCheckerWhenTests { isTypedReferenceNode("x", SUM_TYPE), isSequence( isTypedWhenCaseNode( - equalTo(SumVariant.constructedStruct(constructedVariantType1)), + equalTo(constructedVariantType1), isTypedBlockNode(isSequence( isTypedBlockReturnNode(isTypedStringLiteralNode("a")) )) ), isTypedWhenCaseNode( - equalTo(SumVariant.struct(VARIANT_TYPE_2)), + equalTo(VARIANT_TYPE_2), isTypedBlockNode(isSequence( isTypedBlockReturnNode(isTypedStringLiteralNode("b")) )) @@ -295,8 +295,8 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.constructedStruct(constructedVariantType1), - SumVariant.struct(VARIANT_TYPE_2) + constructedVariantType1, + VARIANT_TYPE_2 ))) .enterGlobal(P.map( Map.entry("Int", Types.metaType(Types.INT)), @@ -359,11 +359,11 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.constructedStruct(Types.constructedStructType( + Types.constructedStructType( variantTypeConstructor1, List.of(TypeParam.forSumType(SUM_TYPE, "T")) - )), - SumVariant.struct(VARIANT_TYPE_2) + ), + VARIANT_TYPE_2 ))) .enterGlobal(P.map( Map.entry("String", Types.metaType(Types.STRING)), @@ -378,13 +378,13 @@ public class TypeCheckerWhenTests { isTypedReferenceNode("x", constructedSumType), isSequence( isTypedWhenCaseNode( - equalTo(SumVariant.constructedStruct(constructedVariantType1)), + equalTo(constructedVariantType1), isTypedBlockNode(isSequence( isTypedBlockReturnNode(isTypedStringLiteralNode("a")) )) ), isTypedWhenCaseNode( - equalTo(SumVariant.struct(VARIANT_TYPE_2)), + equalTo(VARIANT_TYPE_2), isTypedBlockNode(isSequence( isTypedBlockReturnNode(isTypedStringLiteralNode("b")) )) @@ -414,8 +414,8 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.struct(VARIANT_TYPE_1), - SumVariant.struct(VARIANT_TYPE_2) + VARIANT_TYPE_1, + VARIANT_TYPE_2 ))) .enterGlobal(P.map( Map.entry("x", SUM_TYPE), @@ -449,8 +449,8 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.struct(VARIANT_TYPE_1), - SumVariant.struct(VARIANT_TYPE_2) + VARIANT_TYPE_1, + VARIANT_TYPE_2 ))) .enterGlobal(P.map( Map.entry("x", SUM_TYPE), @@ -490,8 +490,8 @@ public class TypeCheckerWhenTests { ); var context = TypeCheckerContext.EMPTY .addSumTypeInfo(SUM_TYPE, new SumTypeInfo(P.orderedSet( - SumVariant.struct(VARIANT_TYPE_1), - SumVariant.struct(VARIANT_TYPE_2) + VARIANT_TYPE_1, + VARIANT_TYPE_2 ))) .addStructTypeInfo( VARIANT_TYPE_1, @@ -517,11 +517,11 @@ public class TypeCheckerWhenTests { isTypedReferenceNode("x", SUM_TYPE), isSequence( isTypedWhenCaseNode( - equalTo(SumVariant.struct(VARIANT_TYPE_1)), + equalTo(VARIANT_TYPE_1), has("type", x -> x.type(), equalTo(Types.STRING)) ), isTypedWhenCaseNode( - equalTo(SumVariant.struct(VARIANT_TYPE_2)), + equalTo(VARIANT_TYPE_2), has("type", x -> x.type(), equalTo(Types.INT)) ) ) diff --git a/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java b/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java index 1c3d90db..524da258 100644 --- a/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java +++ b/src/test/java/org/shedlang/compiler/types/ConstructedTypeTests.java @@ -10,7 +10,7 @@ import static org.zwobble.precisely.Matchers.equalTo; public class ConstructedTypeTests { @Test public void descriptionIsNameOfTypePlusArgsInSquareBrackets() { - var structType = new StructType( + var structType = new SimpleStructType( NamespaceName.of("Example", "Project"), "Map" ); diff --git a/src/test/java/org/shedlang/compiler/types/TypeMatchers.java b/src/test/java/org/shedlang/compiler/types/TypeMatchers.java index c9a37a7d..1112ff64 100644 --- a/src/test/java/org/shedlang/compiler/types/TypeMatchers.java +++ b/src/test/java/org/shedlang/compiler/types/TypeMatchers.java @@ -12,7 +12,7 @@ public class TypeMatchers { public static Matcher isStructType(NamespaceName namespaceName, String name) { return instanceOf( - StructType.class, + SimpleStructType.class, has("namespaceName", x -> x.namespaceName(), equalTo(namespaceName)), has("name", x -> x.name(), equalTo(name)) ); @@ -20,7 +20,7 @@ public class TypeMatchers { public static Matcher isSumType(NamespaceName namespaceName, String name) { return instanceOf( - SumType.class, + SimpleSumType.class, has("namespaceName", x -> x.namespaceName(), equalTo(namespaceName)), has("name", x -> x.name(), equalTo(name)) ); diff --git a/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java b/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java index dd115564..064012f9 100644 --- a/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java +++ b/src/test/java/org/shedlang/compiler/types/TypeSubstitutionTests.java @@ -10,8 +10,8 @@ import static org.zwobble.precisely.Matchers.equalTo; public class TypeSubstitutionTests { private static final NamespaceName NAMESPACE_NAME = NamespaceName.of("Example", "Project"); - private static final StructType STRUCT_TYPE = Types.struct(NAMESPACE_NAME, "Struct"); - private static final StructType STRUCT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Struct2"); + private static final SimpleStructType STRUCT_TYPE = Types.struct(NAMESPACE_NAME, "Struct"); + private static final SimpleStructType STRUCT_TYPE_2 = Types.struct(NAMESPACE_NAME, "Struct2"); @Test public void substitutingBoolDoesNothing() { -- cgit v1.2.3