Refactor of contexts

Author: Gargafield

src/CLI/Program.cs

@@ -45,20 +45,16 @@ public static void Main(string[] args)
                 return;
             }
 
-            var moduleContext = new ModuleContext(type.Module, context);
-            var typeContext = new TypeContext(type, context);
-            var _type = new Core.Type(typeContext);
-            Console.WriteLine(LuauWriter.Write(_type.Compile(), moduleContext));
+            var moduleContext = new ModuleContext(type.Module);
+            var typeContext = new TypeContext(type);
+            Console.WriteLine(LuauWriter.Write(typeContext.Compile(context), moduleContext));
         }
         else {
             var path = args[0];
             var assembly = AssemblyDefinition.ReadAssembly(path);
 
-            var moduleContext = new ModuleContext(assembly.MainModule, context);
-
-            var module = new Module(moduleContext);
-
-            Console.WriteLine(LuauWriter.Write(module.Compile(), moduleContext));
+            var moduleContext = new ModuleContext(assembly.MainModule);
+            Console.WriteLine(LuauWriter.Write(moduleContext.Compile(context), moduleContext));
         }
 
     }

src/Core/Block.cs src/Core/CFG/Block.cs

@@ -23,24 +23,24 @@ private Compiler(ControlTree tree, MethodDefinition method) {
         Scopes.Push(new());
     }
 
-    public static List<Statement> Compile(MethodContext method) {
-        var flow = FlowInfo.From(method.Method.Body.Instructions);
+    public static List<Statement> Compile(MethodDefinition method, TranslationContext translation) {
+        var flow = FlowInfo.From(method.Body.Instructions);
 
-        if (method.TranslationContext.Debug) {
+        if (translation.Debug) {
             Console.WriteLine("CFG:");
             Console.WriteLine(flow.CFG.ToDot());
         }
 
         Restructure.RestructureCFG(flow.CFG);
 
-        if (method.TranslationContext.Debug) {
+        if (translation.Debug) {
             Console.WriteLine("CFG (restructured):");
             Console.WriteLine(flow.CFG.ToDot());
         }
 
         var tree = ControlTree.From(flow.CFG);
 
-        var compiler = new Compiler(tree, method.Method);
+        var compiler = new Compiler(tree, method);
         compiler.Compile();
 
         return compiler.Statements;

src/Core/CFG.cs src/Core/CFG/CFG.cs

@@ -0,0 +1,6 @@
+
+namespace CSynth.Core;
+
+public interface ICompilableContext {
+    public List<Statement> Compile(TranslationContext context);
+}

src/Core/Region.cs src/Core/CFG/Region.cs

@@ -0,0 +1,7 @@
+using System.Reflection.Metadata;
+
+namespace CSynth.Core;
+
+public class MethodContext {
+    public MethodDefinition Definition { get; }
+}

src/Core/Compiler.cs

@@ -0,0 +1,29 @@
+using Mono.Cecil;
+
+namespace CSynth.Core;
+
+public class ModuleContext : ICompilableContext {
+    public ModuleDefinition Module { get; }
+
+    public ModuleContext(ModuleDefinition definition) {
+        Module = definition;
+    }
+
+    public List<Statement> Compile(TranslationContext context) {
+
+        var statements = new List<Statement>();
+
+        foreach (var type in Module.Types.Where(t => t.IsClass)) {
+            var _type = new TypeContext(type);
+            statements.AddRange(_type.Compile(context));
+        }
+
+        if (Module.EntryPoint != null) {
+            var function = new MethodExpression(Module.EntryPoint);
+            var expression = new CallExpression(function, new List<Expression>());
+            statements.Add(new CallStatement(expression));
+        }
+
+        return statements;
+    }
+}

src/Core/Context.cs

@@ -0,0 +1,6 @@
+
+namespace CSynth.Core;
+
+public class TranslationContext {
+    public bool Debug { get; set; }
+}

src/Core/Context/Context.cs

@@ -2,17 +2,15 @@
 
 namespace CSynth.Core;
 
-public class Type {
+public class TypeContext : ICompilableContext {
 
     public TypeDefinition Definition { get; }
-    public TranslationContext Context { get; }
 
-    public Type(TypeContext context) {
-        Definition = context.Type;
-        Context = context.TranslationContext;
+    public TypeContext(TypeDefinition definition) {
+        Definition = definition;
     }
 
-    public List<Statement> Compile() {
+    public List<Statement> Compile(TranslationContext translationContext) {
 
         var statements = new List<Statement>();
 
@@ -25,7 +23,7 @@ public List<Statement> Compile() {
 
         foreach (var method in Definition.Methods) {
             if (!method.HasBody) continue;
-            var compiled = Compiler.Compile(new MethodContext(method, Context));
+            var compiled = Compiler.Compile(method, translationContext);
 
             statements.Add(new MethodDefinitionStatement(method, compiled));
         }

src/Core/Context/MethodContext.cs

@@ -15,16 +15,15 @@ private static void WriteConformanceTests() {
 
         var assemblyPath = typeof(Add_I4_Conformance).Assembly.Location;
         var assembly = AssemblyDefinition.ReadAssembly(assemblyPath);
-        var moduleContext = new ModuleContext(assembly.MainModule, context);
+        var moduleContext = new ModuleContext(assembly.MainModule);
 
         foreach (var type in assembly.MainModule.Types) {
             if (!type.FullName.EndsWith("Conformance")) {
                 continue;
             }
 
-            var typeContext = new TypeContext(type, context);
-            var _type = new Core.Type(typeContext);
-            var statements = _type.Compile();
+            var typeContext = new TypeContext(type);
+            var statements = typeContext.Compile(context);
 
             var function = new MethodExpression(type.Methods.First(m => m.Name == "Main"));
             var expression = new CallExpression(function, new List<Expression>());