diff options
Diffstat (limited to 'src/main/java')
5 files changed, 60 insertions, 20 deletions
diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/ast/untyped/UntypedNamespaceStatementNode.java b/src/main/java/org/zwobble/hobgoblin/compiler/ast/untyped/UntypedNamespaceStatementNode.java index a7be931..a2d3171 100644 --- a/src/main/java/org/zwobble/hobgoblin/compiler/ast/untyped/UntypedNamespaceStatementNode.java +++ b/src/main/java/org/zwobble/hobgoblin/compiler/ast/untyped/UntypedNamespaceStatementNode.java @@ -10,6 +10,8 @@ public sealed interface UntypedNamespaceStatementNode permits org.zwobble.hobgob // Custom area end: org.zwobble.hobgoblin.compiler.ast.untyped.UntypedNamespaceStatementNode.Builder body } + public String name(); + // Custom area start: org.zwobble.hobgoblin.compiler.ast.untyped.UntypedNamespaceStatementNode body // Custom area end: org.zwobble.hobgoblin.compiler.ast.untyped.UntypedNamespaceStatementNode body } diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java index 650cecd..4b718a2 100644 --- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java +++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeChecker.java @@ -19,9 +19,13 @@ public class TypeChecker { ) { var namespaceContext = context.enterNamespace(untyped.namespaceName()); + var fields = new ArrayList<Field>(); for (var untypedStatement : untyped.body()) { - declareNamespaceStatement(untypedStatement, namespaceContext); + var type = declareNamespaceStatement(untypedStatement, namespaceContext); + var field = new Field(untypedStatement.name(), type); + fields.add(field); } + context.defineNamespace(untyped.namespaceName(), fields); var typedBody = new ArrayList<TypedNamespaceStatementNode>(); for (var untypedStatement : untyped.body()) { @@ -36,11 +40,11 @@ public class TypeChecker { ); } - static void declareNamespaceStatement( + static Type declareNamespaceStatement( UntypedNamespaceStatementNode untyped, TypeCheckerNamespaceContext context ) { - switch (untyped) { + return switch (untyped) { case UntypedNativeTypeDefinitionNode untypedNativeTypeDefinition -> declareNativeTypeDefinition(untypedNativeTypeDefinition, context); @@ -49,7 +53,7 @@ public class TypeChecker { case UntypedSumDefinitionNode untypedSumDefinition -> declareSumDefinition(untypedSumDefinition, context); - } + }; } static TypedNamespaceStatementNode defineNamespaceStatement( @@ -68,14 +72,16 @@ public class TypeChecker { }; } - private static void declareNativeTypeDefinition( + private static Type declareNativeTypeDefinition( UntypedNativeTypeDefinitionNode untyped, TypeCheckerNamespaceContext context ) { var nativeType = new SimpleNativeType(context.namespaceName(), untyped.name()); // TODO: tidy up declare vs define context.declare(untyped.name()); - context.define(untyped.name(), new TypeLevelValueType(nativeType)); + var metaType = new TypeLevelValueType(nativeType); + context.define(untyped.name(), metaType); + return metaType; } private static TypedNativeTypeDefinitionNode defineNativeTypeDefinition( @@ -91,14 +97,16 @@ public class TypeChecker { ); } - private static void declareStructDefinition( + private static Type declareStructDefinition( UntypedStructDefinitionNode untyped, TypeCheckerNamespaceContext context ) { var structType = new StructType(context.namespaceName(), untyped.name()); // TODO: tidy up declare vs define context.declare(untyped.name()); - context.define(untyped.name(), new TypeLevelValueType(structType)); + var metaType = new TypeLevelValueType(structType); + context.define(untyped.name(), metaType); + return metaType; } private static TypedStructDefinitionNode defineStructDefinition( @@ -145,14 +153,16 @@ public class TypeChecker { return new TypeCheckFieldDefinitionsResult(typedFields, fields); } - private static void declareSumDefinition( + private static Type declareSumDefinition( UntypedSumDefinitionNode untyped, TypeCheckerNamespaceContext context ) { var sumType = new SumType(context.namespaceName(), untyped.name()); // TODO: tidy up declare vs define context.declare(untyped.name()); - context.define(untyped.name(), new TypeLevelValueType(sumType)); + var metaType = new TypeLevelValueType(sumType); + context.define(untyped.name(), metaType); + return metaType; } private static TypedNamespaceStatementNode defineSumDefinition( diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerGlobalContext.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerGlobalContext.java index 9bc0efb..e50e424 100644 --- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerGlobalContext.java +++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypeCheckerGlobalContext.java @@ -3,13 +3,12 @@ package org.zwobble.hobgoblin.compiler.typechecker; import org.zwobble.hobgoblin.compiler.types.*; import org.zwobble.hobgoblin.compiler.util.ManyToMany; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import java.util.*; public class TypeCheckerGlobalContext { private final Map<String, Type> nativeTypes = new HashMap<>(); - private final Map<StructType, List<Field>> fieldsOf = new HashMap<>(); + private final Map<StructType, List<Field>> structFieldsOf = new HashMap<>(); + private final Map<NamespaceName, Fields> namespaceFieldsOf = new HashMap<>(); private final ManyToMany<SumType, Type> variants = new ManyToMany<>(); public static TypeCheckerGlobalContext initial() { @@ -20,7 +19,7 @@ public class TypeCheckerGlobalContext { } public TypesInfo toTypesInfo() { - return new TypesInfo(this.fieldsOf, this.variants); + return new TypesInfo(this.structFieldsOf, this.variants); } public void addNativeType(SimpleNativeType type) { @@ -35,8 +34,17 @@ public class TypeCheckerGlobalContext { return TypeCheckerNamespaceContext.initial( namespaceName, this.nativeTypes, - this.fieldsOf, + this.structFieldsOf, this.variants ); } + + public void defineNamespace(NamespaceName namespaceName, List<Field> fields) { + this.namespaceFieldsOf.put(namespaceName, new Fields(fields)); + } + + public Fields namespaceFields(NamespaceName namespaceName) { + // TODO: better error handling + return Optional.ofNullable(namespaceFieldsOf.get(namespaceName)).orElseThrow(); + } } diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java index 649ded0..e64a4b8 100644 --- a/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java +++ b/src/main/java/org/zwobble/hobgoblin/compiler/typechecker/TypesInfo.java @@ -11,20 +11,20 @@ import java.util.Map; import java.util.Optional; public class TypesInfo { - private final Map<StructType, List<Field>> fieldsOf; + private final Map<StructType, List<Field>> structFieldsOf; private final ManyToMany<SumType, Type> variants; public TypesInfo( - Map<StructType, List<Field>> fieldsOf, + Map<StructType, List<Field>> structFieldsOf, ManyToMany<SumType, Type> variants ) { - this.fieldsOf = fieldsOf; + this.structFieldsOf = structFieldsOf; this.variants = variants; } public List<Field> fieldsOf(StructType structType) { // TODO: handle error better - return Optional.ofNullable(this.fieldsOf.get(structType)).orElseThrow(); + return Optional.ofNullable(this.structFieldsOf.get(structType)).orElseThrow(); } public List<SumType> variantOf(StructType variantType) { diff --git a/src/main/java/org/zwobble/hobgoblin/compiler/types/Fields.java b/src/main/java/org/zwobble/hobgoblin/compiler/types/Fields.java new file mode 100644 index 0000000..4fc364e --- /dev/null +++ b/src/main/java/org/zwobble/hobgoblin/compiler/types/Fields.java @@ -0,0 +1,20 @@ +package org.zwobble.hobgoblin.compiler.types; + +import java.util.List; + +public class Fields { + private final List<Field> fields; + + public Fields(List<Field> fields) { + this.fields = fields; + } + + public Type get(String name) { + return fields.stream() + .filter(field -> field.name().equals(name)) + .findFirst() + // TODO: better error handling + .orElseThrow() + .type(); + } +} |