Add field index to FieldInfo

4 files changed, 37 insertions, 35 deletions

diff --git a/src/main/java/org/shedlang/compiler/ShedCompiler.java b/src/main/java/org/shedlang/compiler/ShedCompiler.java
index 1c2a471f..325383ae 100644
--- a/src/main/java/org/shedlang/compiler/ShedCompiler.java
+++ b/src/main/java/org/shedlang/compiler/ShedCompiler.java
@@ -42,7 +42,7 @@ public class ShedCompiler {
             .addNamespaceTypeInfo(
                 ShedBuiltins.NAMESPACE_NAME,
                 new NamespaceTypeInfo(FieldsInfo.of(
-                    new FieldInfo<>(ShedBuiltins.PRINT_NAME, ShedBuiltins.PRINT_TYPE)
+                    FieldsInfo.freeField(ShedBuiltins.PRINT_NAME, ShedBuiltins.PRINT_TYPE)
                 ))
             )
             .enterGlobal(P.map(
diff --git a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
index 392e5e87..57798421 100644
--- a/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
+++ b/src/main/java/org/shedlang/compiler/typechecker/TypeChecker.java
@@ -414,13 +414,13 @@ public class TypeChecker {
             public TypeCheckerContext defineTypes(TypeCheckerContext context) {
                 var effect = context.getLexicalState(UserDefinedEffect.class, untyped.name());
 
-                var fields = untyped.methods().stream()
-                    .map(fieldNode -> {
-                        var typedFunctionTypeNode = typeCheckFunctionType(fieldNode.type(), context);
-                        return new FieldInfo<>(fieldNode.name(), typedFunctionTypeNode.value());
-                    });
+                var fieldsInfoBuilder = FieldsInfo.<FunctionType>builder();
 
-                var effectInfo = new UserDefinedEffectInfo(FieldsInfo.from(fields));
+                for (var methodNode : untyped.methods()) {
+                    var typedFunctionTypeNode = typeCheckFunctionType(methodNode.type(), context);
+                    fieldsInfoBuilder = fieldsInfoBuilder.addField(methodNode.name(), typedFunctionTypeNode.value());
+                }
+                var effectInfo = new UserDefinedEffectInfo(fieldsInfoBuilder.build());
 
                 return context.addUserDefinedEffectInfo(effect, effectInfo);
             }
@@ -1211,8 +1211,7 @@ public class TypeChecker {
         var declaredVariables = DeclaredVariables.forImports(untyped.imports(), P.vector());
         declaredVariables = DeclaredVariables.forNamespaceStatements(untyped.body(), declaredVariables);
 
-        var namespaceFinalContext = context;
-        var fieldInfos = declaredVariables.stream()
+        var exportedVariables = declaredVariables.stream()
             .filter(variable -> switch (variable.variableType()) {
                 case CONSTANT -> true;
                 case IMPORT -> false;
@@ -1224,15 +1223,20 @@ public class TypeChecker {
                 case PUBLIC -> true;
                 case PRIVATE -> false;
             })
-            .map(variable -> new FieldInfo<>(
-                variable.name(),
-                namespaceFinalContext.compileTimeLookup(variable.name())
+            .toList();
+
+        var fieldsInfoBuilder = FieldsInfo.builder();
+        for (var exportedVariable : exportedVariables) {
+            fieldsInfoBuilder = fieldsInfoBuilder.addField(
+                exportedVariable.name(),
+                context.compileTimeLookup(exportedVariable.name())
                     .orElseThrow() // TODO: better error
                     .type()
                     .orElseThrow() // TODO: better error
-            ));
+            );
+        }
 
-        var fieldsInfo = FieldsInfo.from(fieldInfos);
+        var fieldsInfo = fieldsInfoBuilder.build();
         var fieldNames = fieldsInfo.keys();
 
         var typed = new TypedNamespaceNode(
@@ -1383,7 +1387,7 @@ public class TypeChecker {
             @Override
             public TypeCheckerContext defineTypes(TypeCheckerContext context) {
                 var typedFieldNodes = new ArrayList<TypedStructFieldDefinitionNode>();
-                var fieldInfos = new ArrayList<FieldInfo<Type>>();
+                var fieldInfosBuilder = FieldsInfo.builder();
 
                 for (var untypedField : untyped.fields()) {
                     var typedFieldNode = new TypedStructFieldDefinitionNode(
@@ -1392,12 +1396,12 @@ public class TypeChecker {
                         untypedField.source()
                     );
                     typedFieldNodes.add(typedFieldNode);
-                    fieldInfos.add(new FieldInfo<>(untypedField.name(), typedFieldNode.type().value()));
+                    fieldInfosBuilder = fieldInfosBuilder.addField(untypedField.name(), typedFieldNode.type().value());
                 }
 
                 var type = context.getLexicalState(StructType.class, untyped.name());
 
-                context = context.addStructTypeInfo(type, new StructTypeInfo(FieldsInfo.from(fieldInfos.stream())));
+                context = context.addStructTypeInfo(type, new StructTypeInfo(fieldInfosBuilder.build()));
 
                 var typedNode = new TypedStructDefinitionNode(
                     type,
diff --git a/src/main/java/org/shedlang/compiler/types/FieldInfo.java b/src/main/java/org/shedlang/compiler/types/FieldInfo.java
index 62a3e75b..dca91202 100644
--- a/src/main/java/org/shedlang/compiler/types/FieldInfo.java
+++ b/src/main/java/org/shedlang/compiler/types/FieldInfo.java
@@ -1,4 +1,4 @@
 package org.shedlang.compiler.types;
 
-public record FieldInfo<T extends Type>(String name, T type) {
+public record FieldInfo<T extends Type>(int fieldIndex, String name, T type) {
 }
diff --git a/src/main/java/org/shedlang/compiler/types/FieldsInfo.java b/src/main/java/org/shedlang/compiler/types/FieldsInfo.java
index 80c68a61..18e2653e 100644
--- a/src/main/java/org/shedlang/compiler/types/FieldsInfo.java
+++ b/src/main/java/org/shedlang/compiler/types/FieldsInfo.java
@@ -2,31 +2,29 @@ package org.shedlang.compiler.types;
 
 import org.pcollections.PVector;
 import org.shedlang.compiler.util.P;
-import org.shedlang.compiler.util.PCollectors;
 import org.shedlang.compiler.util.POrderedMap;
 
-import java.util.Arrays;
 import java.util.Iterator;
-import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Stream;
 
 public record FieldsInfo<T extends Type>(POrderedMap<String, FieldInfo<T>> fields) implements Iterable<FieldInfo<T>> {
-    @SafeVarargs
-    public static <T extends Type> FieldsInfo<T> of(FieldInfo<T>... fields) {
-        return new FieldsInfo<>(
-            Arrays.stream(fields)
-                .map(x -> Map.entry(x.name(), x))
-                .collect(PCollectors.toOrderedMap())
-        );
+    public static <T extends Type> FreeFieldInfo<T> freeField(String name, T type) {
+        return new FreeFieldInfo<>(name, type);
+    }
+
+    public record FreeFieldInfo<T>(String name, T type) {
     }
 
-    public static <T extends Type> FieldsInfo<T> from(Stream<FieldInfo<T>> fields) {
-        return new FieldsInfo<>(
-            fields
-                .map(x -> Map.entry(x.name(), x))
-                .collect(PCollectors.toOrderedMap())
-        );
+    @SafeVarargs
+    public static <T extends Type> FieldsInfo<T> of(FreeFieldInfo<T>... fields) {
+        var builder = FieldsInfo.<T>builder();
+
+        for (var field : fields) {
+            builder = builder.addField(field.name, field.type);
+        }
+
+        return builder.build();
     }
 
     public int fieldCount() {
@@ -70,7 +68,7 @@ public record FieldsInfo<T extends Type>(POrderedMap<String, FieldInfo<T>> field
         }
 
         public Builder<T> addField(String name, T type) {
-            return new Builder<>(fields.plus(name, new FieldInfo<>(name, type)));
+            return new Builder<>(fields.plus(name, new FieldInfo<>(fields.size(), name, type)));
         }
     }
 }