(#72) IR: resolve types for typedefs

ForNeVeR · Feb 16, 2022 · af00de4 · af00de4
1 parent ee70a14
commit af00de4
Show file tree

Hide file tree

Showing 5 changed files with 53 additions and 21 deletions.
diff --git a/Cesium.CodeGen.Tests/CodeGenTypeTests.cs b/Cesium.CodeGen.Tests/CodeGenTypeTests.cs
@@ -53,5 +53,5 @@ void foo(void)
 }");
 
     [Fact]
-    public Task EmptyStructDefinition() => DoTest("typedef struct { int x; } foo;");
+    public Task SingleFieldStructDefinition() => DoTest("typedef struct { int x; } foo;");
 }
diff --git a/Cesium.CodeGen/Contexts/TranslationUnitContext.cs b/Cesium.CodeGen/Contexts/TranslationUnitContext.cs
@@ -10,4 +10,5 @@ public record TranslationUnitContext(AssemblyContext AssemblyContext)
     public TypeSystem TypeSystem => Module.TypeSystem;
     public TypeDefinition ModuleType => Module.GetType("<Module>");
     internal Dictionary<string, FunctionInfo> Functions => AssemblyContext.Functions;
+    internal Dictionary<string, TypeReference> Types { get; } = new();
 }
diff --git a/Cesium.CodeGen/Ir/Declarations/LocalDeclarationInfo.cs b/Cesium.CodeGen/Ir/Declarations/LocalDeclarationInfo.cs
@@ -14,7 +14,7 @@ internal record LocalDeclarationInfo(
     ParametersInfo? Parameters,
     string? CliImportMemberName)
 {
-    public static LocalDeclarationInfo Of(IList<IDeclarationSpecifier> specifiers, Declarator? declarator)
+    public static LocalDeclarationInfo Of(ICollection<IDeclarationSpecifier> specifiers, Declarator? declarator)
     {
         var (type, cliImportMemberName) = ProcessSpecifiers(specifiers);
         if (declarator == null)
@@ -85,7 +85,7 @@ public static LocalDeclarationInfo Of(IList<IDeclarationSpecifier> specifiers, D
     }
 
     private static (IType, string? cliImportMemberName) ProcessSpecifiers(
-        IList<IDeclarationSpecifier> specifiers)
+        ICollection<IDeclarationSpecifier> specifiers)
     {
         IType? type = null;
         var isConst = false;

diff --git a/Cesium.CodeGen/Ir/Declarations/ScopedDeclarationInfo.cs b/Cesium.CodeGen/Ir/Declarations/ScopedDeclarationInfo.cs
@@ -18,18 +18,41 @@ public static IScopedDeclarationInfo Of(Declaration declaration)
 
         if (specifiers.Length > 0 && specifiers[0] is StorageClassSpecifier { Name: "typedef" })
         {
-            return TypeDefDeclaration.Of(specifiers.Skip(1), initDeclarators);
+            return TypeDefOf(specifiers.RemoveAt(0), initDeclarators);
         }
 
-        var initializableDeclarations = initDeclarators
-            .Select<InitDeclarator, InitializableDeclarationInfo>(id => Of(specifiers, id))
+        return IdentifierOf(specifiers, initDeclarators);
+    }
+
+    private static TypeDefDeclaration TypeDefOf(
+        ICollection<IDeclarationSpecifier> specifiers,
+        IEnumerable<InitDeclarator> initDeclarators)
+    {
+        var declarations = initDeclarators.Select(d =>
+        {
+            var (declarator, initializer) = d;
+            if (initializer != null)
+                throw new NotSupportedException($"Initializer is not supported for a typedef.");
+
+            return LocalDeclarationInfo.Of(specifiers, declarator);
+        }).ToList();
+
+        return new TypeDefDeclaration(declarations);
+    }
+
+    private static ScopedIdentifierDeclaration IdentifierOf(
+        ICollection<IDeclarationSpecifier> specifiers,
+        IEnumerable<InitDeclarator> initDeclarators)
+    {
+        var declarations = initDeclarators
+            .Select(id => IdentifierOf(specifiers, id))
             .ToList();
 
-        return new ScopedIdentifierDeclaration(initializableDeclarations);
+        return new ScopedIdentifierDeclaration(declarations);
     }
 
-    private static InitializableDeclarationInfo Of(
-        IList<IDeclarationSpecifier> specifiers,
+    private static InitializableDeclarationInfo IdentifierOf(
+        ICollection<IDeclarationSpecifier> specifiers,
         InitDeclarator initDeclarator)
     {
         var (declarator, initializer) = initDeclarator;
@@ -44,14 +67,6 @@ private static InitializableDeclarationInfo Of(
     }
 }
 
-internal record TypeDefDeclaration : IScopedDeclarationInfo
-{
-    internal static TypeDefDeclaration Of(
-        IEnumerable<IDeclarationSpecifier> specifiers,
-        IEnumerable<InitDeclarator> initDeclarators)
-    {
-        throw new NotSupportedException("typedef not supported, yet.");
-    }
-}
+internal record TypeDefDeclaration(ICollection<LocalDeclarationInfo> Types) : IScopedDeclarationInfo;
 internal record ScopedIdentifierDeclaration(ICollection<InitializableDeclarationInfo> Items) : IScopedDeclarationInfo;
 internal record InitializableDeclarationInfo(LocalDeclarationInfo Declaration, IExpression? Initializer);
diff --git a/Cesium.CodeGen/Ir/TopLevel/TopLevelDeclaration.cs b/Cesium.CodeGen/Ir/TopLevel/TopLevelDeclaration.cs
@@ -23,7 +23,7 @@ public void EmitTo(TranslationUnitContext context)
                 EmitScopedIdentifier(context, declaration);
                 break;
             case TypeDefDeclaration declaration:
-                EmitTypeDef(declaration);
+                EmitTypeDef(context, declaration);
                 break;
             default:
                 throw new ArgumentOutOfRangeException(nameof(_declaration));
@@ -113,6 +113,22 @@ private static void EmitFunctionDeclaration(
         context.Functions.Add(identifier, new FunctionInfo(parametersInfo, returnType, method));
     }
 
-    private static void EmitTypeDef(TypeDefDeclaration declaration) =>
-        throw new NotImplementedException($"typedef is not supported at block level, yet: {declaration}.");
+    private static void EmitTypeDef(TranslationUnitContext context, TypeDefDeclaration declaration)
+    {
+        declaration.Deconstruct(out var types);
+        foreach (var typeDef in types)
+        {
+            var (type, identifier, parametersInfo, cliImportMemberName) = typeDef;
+            if (identifier == null)
+                throw new NotSupportedException($"Anonymous typedef not supported: {type}.");
+
+            if (parametersInfo != null)
+                throw new NotImplementedException($"Function typedef not supported, yet: {identifier}.");
+
+            if (cliImportMemberName != null)
+                throw new NotSupportedException($"typedef for CLI import not supported: {cliImportMemberName}.");
+
+            context.Types.Add(identifier, type.Resolve(context.TypeSystem));
+        }
+    }
 }