Serialize Patio compilation unit elements to flatbuffers

1 files changed, 480 insertions, 0 deletions

diff --git a/src/main/java/org/shedlang/compiler/patio/serialization/PatioToFlatbuffers.java b/src/main/java/org/shedlang/compiler/patio/serialization/PatioToFlatbuffers.java
index acbace10..614f368c 100644
--- a/src/main/java/org/shedlang/compiler/patio/serialization/PatioToFlatbuffers.java
+++ b/src/main/java/org/shedlang/compiler/patio/serialization/PatioToFlatbuffers.java
@@ -2,6 +2,7 @@ package org.shedlang.compiler.patio.serialization;
 
 import com.google.flatbuffers.FlatBufferBuilder;
 import com.google.flatbuffers.IntVector;
+import org.shedlang.compiler.patio.*;
 import org.shedlang.compiler.patio.flatbuffers.*;
 import org.shedlang.compiler.patio.instructions.*;
 import org.shedlang.compiler.patio.operands.*;
@@ -16,6 +17,485 @@ import java.util.Optional;
 import java.util.function.Function;
 
 public class PatioToFlatbuffers {
+    // == Compilation unit elements ==
+
+    public static int serializeCompilationUnitElement(
+        FlatBufferBuilder builder,
+        PatioCompilationUnitElement element,
+        Source parentSource
+    ) {
+        return switch (element) {
+            case PatioDataElementImmutableDefinition dataElementImmutableDefinition -> {
+                var valueFbs = serializeDataElementImmutableDefinition(builder, dataElementImmutableDefinition, parentSource);
+
+                PatioCompilationUnitElementFbs.startPatioCompilationUnitElementFbs(builder);
+                PatioCompilationUnitElementFbs.addValueType(
+                    builder,
+                    PatioCompilationUnitElementValueFbs.PatioDataElementImmutableDefinitionFbs
+                );
+                PatioCompilationUnitElementFbs.addValue(builder, valueFbs);
+                yield PatioCompilationUnitElementFbs.endPatioCompilationUnitElementFbs(builder);
+            }
+
+            case PatioDataElementMutableDeclaration dataElementMutableDeclaration -> {
+                var valueFbs = serializeDataElementMutableDeclaration(builder, dataElementMutableDeclaration, parentSource);
+
+                PatioCompilationUnitElementFbs.startPatioCompilationUnitElementFbs(builder);
+                PatioCompilationUnitElementFbs.addValueType(
+                    builder,
+                    PatioCompilationUnitElementValueFbs.PatioDataElementMutableDeclarationFbs
+                );
+                PatioCompilationUnitElementFbs.addValue(builder, valueFbs);
+                yield PatioCompilationUnitElementFbs.endPatioCompilationUnitElementFbs(builder);
+            }
+
+            case PatioDataElementMutableDefinition dataElementMutableDefinition -> {
+                var valueFbs = serializeDataElementMutableDefinition(builder, dataElementMutableDefinition, parentSource);
+
+                PatioCompilationUnitElementFbs.startPatioCompilationUnitElementFbs(builder);
+                PatioCompilationUnitElementFbs.addValueType(
+                    builder,
+                    PatioCompilationUnitElementValueFbs.PatioDataElementMutableDefinitionFbs
+                );
+                PatioCompilationUnitElementFbs.addValue(builder, valueFbs);
+                yield PatioCompilationUnitElementFbs.endPatioCompilationUnitElementFbs(builder);
+            }
+
+            case PatioExceptionTypeDefinition exceptionTypeDefinition -> {
+                var valueFbs = serializeExceptionTypeDefinition(builder, exceptionTypeDefinition, parentSource);
+
+                PatioCompilationUnitElementFbs.startPatioCompilationUnitElementFbs(builder);
+                PatioCompilationUnitElementFbs.addValueType(
+                    builder,
+                    PatioCompilationUnitElementValueFbs.PatioExceptionTypeDefinitionFbs
+                );
+                PatioCompilationUnitElementFbs.addValue(builder, valueFbs);
+                yield PatioCompilationUnitElementFbs.endPatioCompilationUnitElementFbs(builder);
+            }
+
+            case PatioFunctionDeclaration functionDeclaration -> {
+                var valueFbs = serializeFunctionDeclaration(builder, functionDeclaration, parentSource);
+
+                PatioCompilationUnitElementFbs.startPatioCompilationUnitElementFbs(builder);
+                PatioCompilationUnitElementFbs.addValueType(
+                    builder,
+                    PatioCompilationUnitElementValueFbs.PatioFunctionDeclarationFbs
+                );
+                PatioCompilationUnitElementFbs.addValue(builder, valueFbs);
+                yield PatioCompilationUnitElementFbs.endPatioCompilationUnitElementFbs(builder);
+            }
+
+            case PatioFunctionDefinition functionDefinition -> {
+                var valueFbs = serializeFunctionDefinition(builder, functionDefinition, parentSource);
+
+                PatioCompilationUnitElementFbs.startPatioCompilationUnitElementFbs(builder);
+                PatioCompilationUnitElementFbs.addValueType(
+                    builder,
+                    PatioCompilationUnitElementValueFbs.PatioFunctionDefinitionFbs
+                );
+                PatioCompilationUnitElementFbs.addValue(builder, valueFbs);
+                yield PatioCompilationUnitElementFbs.endPatioCompilationUnitElementFbs(builder);
+            }
+        };
+    }
+
+    public static PatioCompilationUnitElement deserializeCompilationUnitElement(
+        PatioCompilationUnitElementFbs elementFbs,
+        Source parentSource
+    ) {
+        return switch (elementFbs.valueType()) {
+            case PatioCompilationUnitElementValueFbs.PatioDataElementImmutableDefinitionFbs -> {
+                var dataElementImmutableDefinitionFbs =
+                    (PatioDataElementImmutableDefinitionFbs) elementFbs.value(new PatioDataElementImmutableDefinitionFbs());
+                yield deserializeDataElementImmutableDefinition(dataElementImmutableDefinitionFbs, parentSource);
+            }
+
+            case PatioCompilationUnitElementValueFbs.PatioDataElementMutableDeclarationFbs -> {
+                var dataElementMutableDeclarationFbs =
+                    (PatioDataElementMutableDeclarationFbs) elementFbs.value(new PatioDataElementMutableDeclarationFbs());
+                yield deserializeDataElementMutableDeclaration(dataElementMutableDeclarationFbs, parentSource);
+            }
+
+            case PatioCompilationUnitElementValueFbs.PatioDataElementMutableDefinitionFbs -> {
+                var dataElementMutableDefinitionFbs =
+                    (PatioDataElementMutableDefinitionFbs) elementFbs.value(new PatioDataElementMutableDefinitionFbs());
+                yield deserializeDataElementMutableDefinition(dataElementMutableDefinitionFbs, parentSource);
+            }
+
+            case PatioCompilationUnitElementValueFbs.PatioExceptionTypeDefinitionFbs -> {
+                var exceptionTypeDefinitionFbs =
+                    (PatioExceptionTypeDefinitionFbs) elementFbs.value(new PatioExceptionTypeDefinitionFbs());
+                yield deserializeExceptionTypeDefinition(exceptionTypeDefinitionFbs, parentSource);
+            }
+
+            case PatioCompilationUnitElementValueFbs.PatioFunctionDeclarationFbs -> {
+                var functionDeclarationFbs =
+                    (PatioFunctionDeclarationFbs) elementFbs.value(new PatioFunctionDeclarationFbs());
+                yield deserializeFunctionDeclaration(functionDeclarationFbs, parentSource);
+            }
+
+            case PatioCompilationUnitElementValueFbs.PatioFunctionDefinitionFbs -> {
+                var functionDefinitionFbs =
+                    (PatioFunctionDefinitionFbs) elementFbs.value(new PatioFunctionDefinitionFbs());
+                yield deserializeFunctionDefinition(functionDefinitionFbs, parentSource);
+            }
+
+            default ->
+                throw new UnsupportedOperationException("TODO");
+        };
+    }
+
+    private static int serializeDataElementImmutableDefinition(
+        FlatBufferBuilder builder,
+        PatioDataElementImmutableDefinition dataElementImmutableDefinition,
+        Source parentSource
+    ) {
+        var sourceFbs = SourceToFlatbuffers.serializeSource(
+            builder,
+            dataElementImmutableDefinition.source(),
+            parentSource
+        );
+
+        var nameFbs = builder.createString(dataElementImmutableDefinition.name());
+
+        var visibilityFbs = serializeVisibility(dataElementImmutableDefinition.visibility());
+
+        var valueFbs = serializeDataValue(builder, dataElementImmutableDefinition.value());
+
+        PatioDataElementImmutableDefinitionFbs.startPatioDataElementImmutableDefinitionFbs(builder);
+        PatioDataElementImmutableDefinitionFbs.addSource(builder, sourceFbs);
+        PatioDataElementImmutableDefinitionFbs.addName(builder, nameFbs);
+        PatioDataElementImmutableDefinitionFbs.addVisibility(
+            builder,
+            visibilityFbs
+        );
+        PatioDataElementImmutableDefinitionFbs.addValue(builder, valueFbs);
+        return PatioDataElementImmutableDefinitionFbs.endPatioDataElementImmutableDefinitionFbs(builder);
+    }
+
+    private static PatioDataElementImmutableDefinition deserializeDataElementImmutableDefinition(
+        PatioDataElementImmutableDefinitionFbs dataElementImmutableDefinitionFbs,
+        Source parentSource
+    ) {
+        var source = SourceToFlatbuffers.deserializeSource(
+            dataElementImmutableDefinitionFbs.source(),
+            parentSource
+        );
+
+        var name = dataElementImmutableDefinitionFbs.name();
+        var visibility = deserializeVisibility(dataElementImmutableDefinitionFbs.visibility());
+        var value = deserializeDataValue(dataElementImmutableDefinitionFbs.value());
+
+        return new PatioDataElementImmutableDefinition(name, visibility, value, source);
+    }
+
+    private static int serializeDataElementMutableDeclaration(
+        FlatBufferBuilder builder,
+        PatioDataElementMutableDeclaration dataElementMutableDeclaration,
+        Source parentSource
+    ) {
+        var sourceFbs = SourceToFlatbuffers.serializeSource(
+            builder,
+            dataElementMutableDeclaration.source(),
+            parentSource
+        );
+
+        var nameFbs = builder.createString(dataElementMutableDeclaration.name());
+
+        var layoutFbs = serializeDataLayout(builder, dataElementMutableDeclaration.layout());
+
+        PatioDataElementMutableDeclarationFbs.startPatioDataElementMutableDeclarationFbs(builder);
+        PatioDataElementMutableDeclarationFbs.addSource(builder, sourceFbs);
+        PatioDataElementMutableDeclarationFbs.addName(builder, nameFbs);
+        PatioDataElementMutableDeclarationFbs.addLayout(builder, layoutFbs);
+        return PatioDataElementMutableDeclarationFbs.endPatioDataElementMutableDeclarationFbs(builder);
+    }
+
+    private static PatioDataElementMutableDeclaration deserializeDataElementMutableDeclaration(
+        PatioDataElementMutableDeclarationFbs dataElementMutableDeclarationFbs,
+        Source parentSource
+    ) {
+        var source = SourceToFlatbuffers.deserializeSource(
+            dataElementMutableDeclarationFbs.source(),
+            parentSource
+        );
+
+        var name = dataElementMutableDeclarationFbs.name();
+        var layout = deserializeDataLayout(dataElementMutableDeclarationFbs.layout());
+
+        return new PatioDataElementMutableDeclaration(name, layout, source);
+    }
+
+    private static int serializeDataElementMutableDefinition(
+        FlatBufferBuilder builder,
+        PatioDataElementMutableDefinition dataElementMutableDefinition,
+        Source parentSource
+    ) {
+        var sourceFbs = SourceToFlatbuffers.serializeSource(
+            builder,
+            dataElementMutableDefinition.source(),
+            parentSource
+        );
+
+        var nameFbs = builder.createString(dataElementMutableDefinition.name());
+
+        var visibilityFbs = serializeVisibility(dataElementMutableDefinition.visibility());
+
+        var initialValueFbs = serializeDataValue(builder, dataElementMutableDefinition.initialValue());
+
+        PatioDataElementMutableDefinitionFbs.startPatioDataElementMutableDefinitionFbs(builder);
+        PatioDataElementMutableDefinitionFbs.addSource(builder, sourceFbs);
+        PatioDataElementMutableDefinitionFbs.addName(builder, nameFbs);
+        PatioDataElementMutableDefinitionFbs.addVisibility(
+            builder,
+            visibilityFbs
+        );
+        PatioDataElementMutableDefinitionFbs.addInitialValue(builder, initialValueFbs);
+        return PatioDataElementMutableDefinitionFbs.endPatioDataElementMutableDefinitionFbs(builder);
+    }
+
+    private static PatioDataElementMutableDefinition deserializeDataElementMutableDefinition(
+        PatioDataElementMutableDefinitionFbs dataElementMutableDefinitionFbs,
+        Source parentSource
+    ) {
+        var source = SourceToFlatbuffers.deserializeSource(
+            dataElementMutableDefinitionFbs.source(),
+            parentSource
+        );
+
+        var name = dataElementMutableDefinitionFbs.name();
+        var visibility = deserializeVisibility(dataElementMutableDefinitionFbs.visibility());
+        var initialValue = deserializeDataValue(dataElementMutableDefinitionFbs.initialValue());
+
+        return new PatioDataElementMutableDefinition(name, visibility, initialValue, source);
+    }
+
+    private static int serializeExceptionTypeDefinition(
+        FlatBufferBuilder builder,
+        PatioExceptionTypeDefinition exceptionTypeDefinition,
+        Source parentSource
+    ) {
+        var sourceFbs = SourceToFlatbuffers.serializeSource(
+            builder,
+            exceptionTypeDefinition.source(),
+            parentSource
+        );
+
+        var nameFbs = builder.createString(exceptionTypeDefinition.name());
+        var valueTypeFbs = serializeType(builder, exceptionTypeDefinition.valueType());
+
+        PatioExceptionTypeDefinitionFbs.startPatioExceptionTypeDefinitionFbs(builder);
+        PatioExceptionTypeDefinitionFbs.addSource(builder, sourceFbs);
+        PatioExceptionTypeDefinitionFbs.addName(builder, nameFbs);
+        PatioExceptionTypeDefinitionFbs.addValueType(builder, valueTypeFbs);
+        return PatioExceptionTypeDefinitionFbs.endPatioExceptionTypeDefinitionFbs(builder);
+    }
+
+    private static PatioExceptionTypeDefinition deserializeExceptionTypeDefinition(
+        PatioExceptionTypeDefinitionFbs exceptionTypeDefinitionFbs,
+        Source parentSource
+    ) {
+        var source = SourceToFlatbuffers.deserializeSource(
+            exceptionTypeDefinitionFbs.source(),
+            parentSource
+        );
+
+        var name = exceptionTypeDefinitionFbs.name();
+        var valueType = deserializeType(exceptionTypeDefinitionFbs.valueType());
+
+        return new PatioExceptionTypeDefinition(name, valueType, source);
+    }
+
+    private static int serializeFunctionDeclaration(
+        FlatBufferBuilder builder,
+        PatioFunctionDeclaration functionDeclaration,
+        Source parentSource
+    ) {
+        var sourceFbs = SourceToFlatbuffers.serializeSource(
+            builder,
+            functionDeclaration.source(),
+            parentSource
+        );
+
+        var nameFbs = builder.createString(functionDeclaration.name());
+
+        var paramsOffsetsFbs = functionDeclaration.params().stream()
+            .mapToInt(param -> serializeLocal(builder, param))
+            .toArray();
+        var paramsVectorFbs = PatioFunctionDeclarationFbs.createParamsVector(builder, paramsOffsetsFbs);
+
+        var returnTypeFbs = serializeType(builder, functionDeclaration.returnType());
+
+        PatioFunctionDeclarationFbs.startPatioFunctionDeclarationFbs(builder);
+        PatioFunctionDeclarationFbs.addSource(builder, sourceFbs);
+        PatioFunctionDeclarationFbs.addName(builder, nameFbs);
+        PatioFunctionDeclarationFbs.addParams(builder, paramsVectorFbs);
+        PatioFunctionDeclarationFbs.addReturnType(builder, returnTypeFbs);
+        return PatioFunctionDeclarationFbs.endPatioFunctionDeclarationFbs(builder);
+    }
+
+    private static PatioFunctionDeclaration deserializeFunctionDeclaration(
+        PatioFunctionDeclarationFbs functionDeclarationFbs,
+        Source parentSource
+    ) {
+        var source = SourceToFlatbuffers.deserializeSource(
+            functionDeclarationFbs.source(),
+            parentSource
+        );
+
+        var name = functionDeclarationFbs.name();
+        var params = deserializeVector(
+            functionDeclarationFbs::params,
+            functionDeclarationFbs.paramsLength(),
+            PatioToFlatbuffers::deserializeLocal
+        );
+        var returnType = deserializeType(functionDeclarationFbs.returnType());
+
+        return new PatioFunctionDeclaration(name, params, returnType, source);
+    }
+
+    private static int serializeFunctionDefinition(
+        FlatBufferBuilder builder,
+        PatioFunctionDefinition functionDefinition,
+        Source parentSource
+    ) {
+        var sourceFbs = SourceToFlatbuffers.serializeSource(
+            builder,
+            functionDefinition.source(),
+            parentSource
+        );
+
+        var nameFbs = builder.createString(functionDefinition.name());
+
+        var visibilityFbs = serializeVisibility(functionDefinition.visibility());
+
+        var localsOffsetsFbs = functionDefinition.locals().stream()
+            .mapToInt(local -> serializeLocal(builder, local))
+            .toArray();
+        var localsVectorFbs = PatioFunctionDefinitionFbs.createLocalsVector(builder, localsOffsetsFbs);
+
+        var returnTypeFbs = serializeType(builder, functionDefinition.returnType());
+
+        var bodyOffsetsFbs = functionDefinition.body().stream()
+            .mapToInt(bodyInstruction -> serializeInstruction(builder, bodyInstruction, functionDefinition.source()))
+            .toArray();
+        var bodyVectorFbs = PatioFunctionDefinitionFbs.createBodyVector(builder, bodyOffsetsFbs);
+
+        PatioFunctionDefinitionFbs.startPatioFunctionDefinitionFbs(builder);
+        PatioFunctionDefinitionFbs.addSource(builder, sourceFbs);
+        PatioFunctionDefinitionFbs.addName(builder, nameFbs);
+        PatioFunctionDefinitionFbs.addVisibility(
+            builder,
+            visibilityFbs
+        );
+        PatioFunctionDefinitionFbs.addLocals(builder, localsVectorFbs);
+        PatioFunctionDefinitionFbs.addReturnType(builder, returnTypeFbs);
+        PatioFunctionDefinitionFbs.addBody(builder, bodyVectorFbs);
+        return PatioFunctionDefinitionFbs.endPatioFunctionDefinitionFbs(builder);
+    }
+
+    private static PatioFunctionDefinition deserializeFunctionDefinition(
+        PatioFunctionDefinitionFbs functionDefinitionFbs,
+        Source parentSource
+    ) {
+        var source = SourceToFlatbuffers.deserializeSource(
+            functionDefinitionFbs.source(),
+            parentSource
+        );
+
+        var name = functionDefinitionFbs.name();
+        var visibility = deserializeVisibility(functionDefinitionFbs.visibility());
+        var locals = deserializeVector(
+            functionDefinitionFbs::locals,
+            functionDefinitionFbs.localsLength(),
+            PatioToFlatbuffers::deserializeLocal
+        );
+        var returnType = deserializeType(functionDefinitionFbs.returnType());
+        var body = deserializeVector(
+            functionDefinitionFbs::body,
+            functionDefinitionFbs.bodyLength(),
+            instructionFbs -> deserializeInstruction(instructionFbs, source)
+        );
+
+        return new PatioFunctionDefinition(name, visibility, locals, returnType, body, source);
+    }
+
+    // == Visibility ==
+
+    private static int serializeVisibility(PatioVisibility visibility) {
+        return switch (visibility) {
+            case PRIVATE ->
+                PatioVisibilityFbs.PRIVATE;
+
+            case PUBLIC ->
+                PatioVisibilityFbs.PUBLIC;
+        };
+    }
+
+    private static PatioVisibility deserializeVisibility(int visibilityFbs) {
+        return switch (visibilityFbs) {
+            case PatioVisibilityFbs.PRIVATE ->
+                PatioVisibility.PRIVATE;
+
+            case PatioVisibilityFbs.PUBLIC ->
+                PatioVisibility.PUBLIC;
+
+            default ->
+                throw new UnsupportedOperationException("TODO");
+        };
+    }
+
+    // == Locals ==
+
+    private static int serializeLocal(FlatBufferBuilder builder, PatioLocal local) {
+        var nameFbs = builder.createString(local.name());
+        var typeFbs = serializeType(builder, local.type());
+        var localTypeFbs = serializeLocalType(local.localType());
+
+        PatioLocalFbs.startPatioLocalFbs(builder);
+        PatioLocalFbs.addName(builder, nameFbs);
+        PatioLocalFbs.addType(builder, typeFbs);
+        PatioLocalFbs.addLocalType(builder, localTypeFbs);
+        return PatioLocalFbs.endPatioLocalFbs(builder);
+    }
+
+    private static PatioLocal deserializeLocal(PatioLocalFbs localFbs) {
+        var name = localFbs.name();
+        var type = deserializeType(localFbs.type());
+        var localType = deserializeLocalType(localFbs.localType());
+
+        return new PatioLocal(name, type, localType);
+    }
+
+    private static int serializeLocalType(PatioLocalType localType) {
+        return switch (localType) {
+            case PARAM ->
+                PatioLocalTypeFbs.PARAM;
+
+            case VAL ->
+                PatioLocalTypeFbs.VAL;
+
+            case VAR ->
+                PatioLocalTypeFbs.VAR;
+        };
+    }
+
+    private static PatioLocalType deserializeLocalType(int localTypeFbs) {
+        return switch (localTypeFbs) {
+            case PatioLocalTypeFbs.PARAM ->
+                PatioLocalType.PARAM;
+
+            case PatioLocalTypeFbs.VAL ->
+                PatioLocalType.VAL;
+
+            case PatioLocalTypeFbs.VAR ->
+                PatioLocalType.VAR;
+
+            default ->
+                throw new UnsupportedOperationException("TODO");
+        };
+    }
+
     // == Instructions ==
 
     public static int serializeInstruction(