feat: prework for type aliases

NewSource/Socordia.CodeAnalysis/AST/RootBlock.cs

@@ -1,3 +1,8 @@
+using Socordia.CodeAnalysis.Parsing.ParsePoints.Declarations;
+
 namespace Socordia.CodeAnalysis.AST;
 
-public class RootBlock(IEnumerable<AstNode> body) : Block(body);
+public class RootBlock(IEnumerable<AstNode> body) : Block(body)
+{
+    public Scope Scope { get; set; } = new Scope(null);
+}

NewSource/Socordia.CodeAnalysis/AST/TypeAliasDeclaration.cs

@@ -0,0 +1,14 @@
+namespace Socordia.CodeAnalysis.AST;
+
+// using t as System.Int32;
+// using t as i32;
+public class TypeAliasDeclaration : AstNode
+{
+    public TypeAliasDeclaration(AstNode expr)
+    {
+        Children.Add(expr);
+    }
+
+    public AstNode Name => Children.First.Children[0];
+    public AstNode Type => Children.First.Children[1];
+}

NewSource/Socordia.CodeAnalysis/Parsing/ParsePoints/Declarations/TypeAliasDeclaration.cs

@@ -12,6 +12,6 @@ public static AstNode Parse(TokenIterator iterator, Parser parser)
 
         iterator.Match(TokenType.Semicolon);
 
-        return new TypeAlias(expr);
+        return new TypeAliasDeclaration(expr);
     }
 }

NewSource/SocordiaC/Compilation/Listeners/TypeAliasListener.cs

@@ -0,0 +1,16 @@
+using MrWatkins.Ast.Listening;
+using Socordia.CodeAnalysis.AST;
+
+namespace SocordiaC.Compilation;
+
+public class TypeAliasListener : Listener<Driver, AstNode, TypeAliasDeclaration>
+{
+    protected override void ListenToNode(Driver context, TypeAliasDeclaration node)
+    {
+        var root = (RootBlock)node.Root.Scope;
+
+        root.Scope.TypeAliases.Add(node.Name, node.Type);
+    }
+
+    protected override bool ShouldListenToChildren(BodyCompilation context, TypeAliasDeclaration node) => false;
+}

NewSource/SocordiaC/Compilation/Scoping/Scope.cs

@@ -12,10 +12,20 @@ public Scope(Scope parent)
     {
         Parent = parent;
         TypeAliases = new Dictionary<string, TypeDesc>();
+
+        if (parent == null)
+        {
+            Root = this;
+        }
+        else
+        {
+            Root = parent.Root;
+        }
     }
 
     public Dictionary<string, TypeDesc> TypeAliases { get; set; }
     public Scope Parent { get; set; }
+    public Scope Root { get; set; }
 
     public bool Add(ScopeItem item)
     {
@@ -89,4 +99,9 @@ public object GetFromNode(AstNode node)
 
         return null;
     }
+
+    public bool TryGetTypeAlias(string name, out TypeDesc? type)
+    {
+        return Root.TypeAliases.TryGetValue(name, out type);
+    }
 }

NewSource/SocordiaC/Compilation/Utils.cs

@@ -53,9 +53,14 @@ public static partial class Utils
 
         if (node is SimpleTypeName id)
         {
+            if ((((RootBlock)node.Root).Scope).TryGetTypeAlias(id.Name, out var alias))
+            {
+                return alias;
+            }
+
             if (Primities.TryGetValue(id.Name, out var prim))
             {
-                return prim;
+                    return prim;
             }
 
             var type = containingType.Module.FindType(containingType.Namespace, id.Name);

NewSource/SocordiaC/Stages/CollectTypesStage.cs

@@ -1,6 +1,7 @@
 using Flo;
 using MrKWatkins.Ast.Listening;
 using Socordia.CodeAnalysis.AST;
+using SocordiaC.Compilation;
 using SocordiaC.Compilation.Listeners;
 
 namespace SocordiaC.Stages;
@@ -9,7 +10,10 @@ public class CollectTypesStage : IHandler<Driver, Driver>
 {
     public async Task<Driver> HandleAsync(Driver context, Func<Driver, Task<Driver>> next)
     {
-        var collectTypesPipeline = CompositeListener<Driver, AstNode>.Build()
+        var prePhase = CompositeListener<Driver, AstNode>.Build()
+            .With(new TypeAliasListener());
+
+        var firstPhasePipeline = CompositeListener<Driver, AstNode>.Build()
             .With(new CollectClassesListener())
             .With(new CollectStructsListener())
             .With(new CollectEnumListener())
@@ -20,19 +24,31 @@ public async Task<Driver> HandleAsync(Driver context, Func<Driver, Task<Driver>>
             .ToListener();
 
         foreach (var tree in context.Trees)
-        foreach (var decl in tree.Declarations.Children)
         {
-            collectTypesPipeline.Listen(context, decl);
+            foreach (var decl in tree.Declarations.Children)
+            {
+                prePhase.Listen(context, decl);
+            }
         }
 
-        var functionCollector = new CollectFunctionsListener();
-        var globalVarListener = new CollectGlobalVariablesListener();
         foreach (var tree in context.Trees)
         {
             foreach (var decl in tree.Declarations.Children)
             {
-                functionCollector.Listen(context, decl);
-                globalVarListener.Listen(context, decl);
+                firstPhasePipeline.Listen(context, decl);
+            }
+        }
+
+        var secondPhasePipeline = CompositeListener<Driver, AstNode>.Build()
+            .With(new CollectFunctionsListener())
+            .With(new CollectGlobalVariablesListener())
+            .ToListener();
+
+        foreach (var tree in context.Trees)
+        {
+            foreach (var decl in tree.Declarations.Children)
+            {
+                secondPhasePipeline.Listen(context, decl);
             }
         }
 

NewSource/SocordiaC/Stages/CompileFunctionsStage.cs

@@ -3,6 +3,7 @@
 using DistIL.IR;
 using DistIL.IR.Utils;
 using Flo;
+using Socordia.CodeAnalysis.AST;
 using Socordia.CodeAnalysis.AST.Declarations;
 using SocordiaC.Compilation;
 using SocordiaC.Compilation.Listeners.Body;
@@ -17,14 +18,15 @@ public async Task<Driver> HandleAsync(Driver context, Func<Driver, Task<Driver>>
     {
         foreach (var (node, def) in Mappings.Functions)
         {
-            var scope = new Scope(null!);
+            var scope = ((RootBlock)def.Root).Scope.CreateSubScope();
             foreach (var arg in def.Body!.Args)
             {
                 scope.Add(new ParameterScopeItem { Name = arg.Name, Arg = arg, IsOut = def.IsOut });
             }
 
             var builder = new IRBuilder(def.Body!.CreateBlock());
             EmitParameterNullChecks(builder, node, context);
+
             var bodyCompilation = new BodyCompilation(context, def, builder, scope);
 
             if (!node.Children[1].HasChildren)