feat: Add typeof expression

NewSource/Socordia.CodeAnalysis/AST/Expressions/TypeOfExpression.cs

@@ -0,0 +1,13 @@
+using Socordia.CodeAnalysis.AST.TypeNames;
+
+namespace Socordia.CodeAnalysis.AST.Expressions;
+
+public class TypeOfExpression : AstNode
+{
+    public TypeOfExpression(TypeName type)
+    {
+        Properties.Set(nameof(Type), type);
+    }
+
+    public TypeName Type => Properties.GetOrThrow<TypeName>(nameof(Type));
+}

NewSource/Socordia.CodeAnalysis/Parsing/ParsePoints/Expressions/TypeOfExpressionParser.cs

@@ -1,4 +1,5 @@
 using Socordia.CodeAnalysis.AST;
+using Socordia.CodeAnalysis.AST.Expressions;
 
 namespace Socordia.CodeAnalysis.Parsing.ParsePoints.Expressions;
 
@@ -12,6 +13,6 @@ public static AstNode Parse(TokenIterator iterator, Parser parser)
 
         iterator.Match(TokenType.CloseParen);
 
-        return SyntaxTree.TypeOfExpression(type);
+        return new TypeOfExpression(type);
     }
 }

NewSource/Socordia.CodeAnalysis/Parsing/SyntaxTree.cs

@@ -200,11 +200,6 @@ public static AstNode Unit(AstNode value, string unit)
         return new UnitLiteral(value, unit);
     }
 
-    public static AstNode TypeOfExpression(AstNode type)
-    {
-        return new TypeOf(type);
-    }
-
     public static AstNode DoWhile(Block body, AstNode cond)
     {
         return new DoWhileStatement(body, cond);

NewSource/SocordiaC/Compilation/Utils.cs

@@ -7,6 +7,7 @@
 using Socordia.CodeAnalysis.AST.Literals;
 using Socordia.CodeAnalysis.AST.TypeNames;
 using Socordia.CodeAnalysis.Parsing;
+using Socordia.CodeAnalysis.Parsing.ParsePoints.Expressions;
 using SocordiaC.Compilation.Body;
 
 namespace SocordiaC.Compilation;
@@ -176,10 +177,23 @@ public static Value CreateValue(AstNode valueNode, BodyCompilation compilation)
             LiteralNode literal => CreateLiteral(literal.Value),
             DefaultLiteral def => CreateDefault(def, compilation),
             CallExpression call => CreateCall(call, compilation),
+            TypeOfExpression typeOf => CreateTypeOf(typeOf, compilation),
             _ => throw new NotImplementedException()
         };
     }
 
+    private static Value CreateTypeOf(TypeOfExpression typeOf, BodyCompilation compilation)
+    {
+        var type = GetTypeFromNode(typeOf.Type, compilation.Driver.Compilation.Module)!;
+
+        var ldToken = compilation.Builder.Emit(new CilIntrinsic.LoadHandle(compilation.Method.Module.Resolver, type));
+
+        var typeType = compilation.Builder.Resolver.Import(typeof(Type));
+        var fromTokenMethod = typeType.FindMethod("GetTypeFromHandle")!;
+
+        return new CallInst(fromTokenMethod, [ldToken]);
+    }
+
     private static Value CreateCall(CallExpression call, BodyCompilation compilation)
     {
         var listener = new CallExpressionListener(false);

NewSource/SocordiaC/compilation.sc

@@ -13,6 +13,7 @@ func unit(x: unit cm): none
 func main(): none  {
     let myFlag = true;
     let t = test(1, false);
+    let t : System.Type = typeof(i32);
 
     print("hello");
     println("world");