Struct Layouts (#898)

HurricanKai · web-flow · commit a2806138d2c8 · 2022-04-20T20:00:25.000+01:00
* Restructure Struct to allow layouting

* Add failing layout tests

* Apply Layouting attributes

* Accept StructLayout attribute on empty structs
diff --git a/src/generators/Silk.NET.SilkTouch.Emitter/CSharpEmitter.cs b/src/generators/Silk.NET.SilkTouch.Emitter/CSharpEmitter.cs
@@ -69,14 +69,39 @@ protected override StructSymbol VisitStruct(StructSymbol structSymbol)
                 throw new InvalidOperationException("Field Identifier was not visited correctly");
             ClearState();
 
-            var memberList = new List<MemberDeclarationSyntax>(structSymbol.Members.Length);
-            foreach (var member in structSymbol.Members)
+            var memberList = new List<MemberDeclarationSyntax>(structSymbol.Layout.Entries.Length);
+            foreach (var entry in structSymbol.Layout.Entries)
             {
-                VisitMember(member);
+                VisitMember(entry.Member);
                 if (_syntax is not MemberDeclarationSyntax memberDeclarationSyntax)
                     throw new InvalidOperationException("Member was not visited correctly");
                 ClearState();
                 memberDeclarationSyntax = memberDeclarationSyntax.WithLeadingTrivia(LineFeed, _indentation);
+                memberDeclarationSyntax = memberDeclarationSyntax.WithAttributeLists
+                (
+                    SingletonList
+                    (
+                        AttributeList
+                        (
+                            SingletonSeparatedList
+                            (
+                                Attribute
+                                        (IdentifierName("FieldOffset"))
+                                    .WithArgumentList
+                                    (
+                                        AttributeArgumentList
+                                        (
+                                            SingletonSeparatedList
+                                            (
+                                                AttributeArgument
+                                                    (LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(entry.ByteOffset)))
+                                            )
+                                        )
+                                    )
+                            )
+                        )
+                    )
+                ).WithLeadingTrivia(LineFeed, _indentation);
                 memberList.Add(memberDeclarationSyntax);
             }
             
@@ -85,8 +110,34 @@ protected override StructSymbol VisitStruct(StructSymbol structSymbol)
             var modifiers = TokenList(Token(SyntaxTriviaList.Empty, SyntaxKind.PublicKeyword, TriviaList(Space)));
             _syntax = StructDeclaration
                 (
-                    List<AttributeListSyntax>(), modifiers, identifierToken, null, null,
-                    List<TypeParameterConstraintClauseSyntax>(), members
+                    SingletonList
+                    (
+                        AttributeList
+                            (
+                                SingletonSeparatedList
+                                (
+                                    Attribute(IdentifierName("StructLayout"))
+                                        .WithArgumentList
+                                        (
+                                            AttributeArgumentList
+                                            (
+                                                SingletonSeparatedList
+                                                (
+                                                    AttributeArgument
+                                                    (
+                                                        MemberAccessExpression
+                                                        (
+                                                            SyntaxKind.SimpleMemberAccessExpression,
+                                                            IdentifierName("LayoutKind"), IdentifierName("Explicit")
+                                                        )
+                                                    )
+                                                )
+                                            )
+                                        )
+                                )
+                            )
+                            .WithTrailingTrivia(LineFeed)
+                    ), modifiers, identifierToken, null, null, List<TypeParameterConstraintClauseSyntax>(), members
                 )
                 .WithKeyword(Token(SyntaxTriviaList.Empty, SyntaxKind.StructKeyword, TriviaList(Space)))
                 .WithOpenBraceToken(Token(TriviaList(LineFeed), SyntaxKind.OpenBraceToken, SyntaxTriviaList.Empty))
diff --git a/src/generators/Silk.NET.SilkTouch.Symbols/StructSymbol.cs b/src/generators/Silk.NET.SilkTouch.Symbols/StructSymbol.cs
@@ -9,11 +9,31 @@ namespace Silk.NET.SilkTouch.Symbols;
 /// A <see cref="TypeSymbol"/> representing a <c>struct</c>.
 /// </summary>
 /// <param name="Identifier">The Identifier of this struct</param>
-/// <param name="Members">The Members of this struct</param>
+/// <param name="Layout">The layout of this struct</param>
 /// <remarks>
 /// In this context, a Struct means a type that represents the layout of a continuous block of memory.
 /// </remarks>
 // /// Each meaningful place in this memory called a field (see <see cref="FieldSymbol"/>) is accessible via this type.
 // /// Fields are allowed to overlap.
 // /// Additionally it may contain one or multiple <see cref="MethodSymbol"/> that are called with an instance of this type as their first argument.
-public sealed record StructSymbol(IdentifierSymbol Identifier, ImmutableArray<MemberSymbol> Members) : TypeSymbol(Identifier);
+public sealed record StructSymbol(IdentifierSymbol Identifier, StructLayout Layout) : TypeSymbol(Identifier);
+
+/// <summary>
+/// A <see cref="StructSymbol"/> representing the layout of a <see cref="StructSymbol"/>
+/// </summary>
+/// <param name="Entries">The entries of this layout</param>
+public sealed record StructLayout(ImmutableArray<LayoutEntry> Entries)
+{
+    /// <summary>
+    /// An empty layout with no members
+    /// </summary>
+    public static readonly StructLayout Empty = new StructLayout(ImmutableArray<LayoutEntry>.Empty);
+}
+
+/// <summary>
+/// Represents an entry in a <see cref="StructLayout"/>
+/// </summary>
+/// <param name="Member">The member symbol associated with this layout entry</param>
+/// <param name="ByteOffset">The offset of this entry in bytes</param>
+/// <seealso cref="StructLayout"/>
+public sealed record LayoutEntry(MemberSymbol Member, int ByteOffset);
diff --git a/src/generators/Silk.NET.SilkTouch.Symbols/SymbolVisitor.cs b/src/generators/Silk.NET.SilkTouch.Symbols/SymbolVisitor.cs
@@ -75,7 +75,16 @@ protected virtual TypeSymbol VisitType(TypeSymbol typeSymbol)
     /// </remarks>
     protected virtual StructSymbol VisitStruct(StructSymbol structSymbol)
     {
-        return new StructSymbol(VisitIdentifier(structSymbol.Identifier), structSymbol.Members.Select(VisitMember).ToImmutableArray());
+        return new StructSymbol
+        (
+            VisitIdentifier(structSymbol.Identifier),
+            new StructLayout
+            (
+                structSymbol.Layout.Entries.Select
+                        (x => new LayoutEntry(VisitMember(x.Member), x.ByteOffset))
+                    .ToImmutableArray()
+            )
+        );
     }
 
     /// <summary>
diff --git a/tests/Silk.NET.SilkTouch.Emitter.Tests/EmitterFieldTests.cs b/tests/Silk.NET.SilkTouch.Emitter.Tests/EmitterFieldTests.cs
@@ -12,7 +12,7 @@ public sealed class EmitterFieldIntegrationTests : EmitterTest
     [Fact]
     public void StructHasStructKeyword()
     {
-        var syntax = Transform(new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test")));
+        var syntax = Transform(new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"),StructLayout.Empty), new IdentifierSymbol("Test")));
 
         var result = syntax.ToFullString();
         Assert.Equal("public int Test;", result);
diff --git a/tests/Silk.NET.SilkTouch.Emitter.Tests/EmitterStructMemberFieldsTests.cs b/tests/Silk.NET.SilkTouch.Emitter.Tests/EmitterStructMemberFieldsTests.cs
@@ -16,22 +16,67 @@ public void StructWithSingleFieldIntegration()
         (
             new StructSymbol
             (
-                new IdentifierSymbol("Test"), (new[]
+                new IdentifierSymbol("Test"), new StructLayout((new[]
                 {
-                    (MemberSymbol) new FieldSymbol
+                    new LayoutEntry(new FieldSymbol
                     (
-                        new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty),
+                        new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty),
                         new IdentifierSymbol("F1")
-                    )
-                }).ToImmutableArray()
+                    ), 0)   
+                }).ToImmutableArray())
             )
         );
 
         Assert.Equal
         (
-            @"public struct Test
+            @"[StructLayout(LayoutKind.Explicit)]
+public struct Test
 {
+    [FieldOffset(0)]
     public int F1;
+}", node.ToFullString()
+        );
+    }
+    
+    [Fact]
+    public void StructWithMultipleFieldsIntegration()
+    {
+        var node = Transform
+        (
+            new StructSymbol
+            (
+                new IdentifierSymbol("Test"), new StructLayout((new[]
+                {
+                    new LayoutEntry(new FieldSymbol
+                    (
+                        new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty),
+                        new IdentifierSymbol("F1")
+                    ), 0),
+                    new LayoutEntry(new FieldSymbol
+                    (
+                        new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty),
+                        new IdentifierSymbol("F2")
+                    ), 20),
+                    new LayoutEntry(new FieldSymbol
+                    (
+                        new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty),
+                        new IdentifierSymbol("F3")
+                    ), 12)
+                }).ToImmutableArray())
+            )
+        );
+
+        Assert.Equal
+        (
+            @"[StructLayout(LayoutKind.Explicit)]
+public struct Test
+{
+    [FieldOffset(0)]
+    public int F1;
+    [FieldOffset(20)]
+    public int F2;
+    [FieldOffset(12)]
+    public int F3;
 }", node.ToFullString()
         );
     }
diff --git a/tests/Silk.NET.SilkTouch.Emitter.Tests/EmitterStructTests.cs b/tests/Silk.NET.SilkTouch.Emitter.Tests/EmitterStructTests.cs
@@ -13,28 +13,28 @@ public sealed class EmitterStructTests : EmitterTest
     [Fact]
     public void StructIsStructSyntax()
     {
-        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty));
+        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty));
         Assert.IsType<StructDeclarationSyntax>(syntax);
     }
 
     [Fact]
     public void StructHasStructKeyword()
     {
-        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)) as StructDeclarationSyntax;
+        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)) as StructDeclarationSyntax;
         Assert.Equal("struct", syntax!.Keyword.Text);
     }
 
     [Fact]
     public void StructHasCorrectIdentifier()
     {
-        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)) as StructDeclarationSyntax;
+        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)) as StructDeclarationSyntax;
         Assert.Equal("Test", syntax!.Identifier.Text);
     }
 
     [Fact]
     public void StructIsOnlyPublic()
     {
-        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)) as StructDeclarationSyntax;
+        var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)) as StructDeclarationSyntax;
         var @public = Assert.Single(syntax!.Modifiers);
         Assert.Equal("public", @public.Text);
     }
@@ -43,8 +43,9 @@ public void StructIsOnlyPublic()
     public void IntegrationEmptyStruct()
     {
         // Note that this test also covers trivia, which is not checked otherwise.
-        Assert.Equal(@"public struct Test
+        Assert.Equal(@"[StructLayout(LayoutKind.Explicit)]
+public struct Test
 {
-}", Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)).ToFullString());
+}", Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)).ToFullString());
     }
 }
diff --git a/tests/Silk.NET.SilkTouch.Symbols.Tests/SymbolVisitorTests/FieldTests.cs b/tests/Silk.NET.SilkTouch.Symbols.Tests/SymbolVisitorTests/FieldTests.cs
@@ -13,7 +13,7 @@ public class FieldTests
     [Fact]
     public void FieldIsVisitedAsField()
     {
-        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));
+        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
@@ -28,7 +28,7 @@ public void FieldIsVisitedAsField()
     [Fact]
     public void FieldIsVisitedAsMember()
     {
-        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));
+        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
@@ -43,7 +43,7 @@ public void FieldIsVisitedAsMember()
     [Fact]
     public void FieldTypeIsVisited()
     {
-        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));
+        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
@@ -58,7 +58,7 @@ public void FieldTypeIsVisited()
     [Fact]
     public void FieldIdentifierIsVisited()
     {
-        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));
+        var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
diff --git a/tests/Silk.NET.SilkTouch.Symbols.Tests/SymbolVisitorTests/StructTests.cs b/tests/Silk.NET.SilkTouch.Symbols.Tests/SymbolVisitorTests/StructTests.cs
@@ -13,7 +13,7 @@ public class StructTests
     [Fact]
     public void StructSymbolIsVisitedAsType()
     {
-        var symbol = new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty);
+        var symbol = new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty);
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
@@ -28,7 +28,7 @@ public void StructSymbolIsVisitedAsType()
     [Fact]
     public void StructSymbolIsVisitedAsStruct()
     {
-        var symbol = new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty);
+        var symbol = new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty);
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
@@ -43,7 +43,7 @@ public void StructSymbolIsVisitedAsStruct()
     [Fact]
     public void StructIdentifierIsVisitedAsIdentifier()
     {
-        var symbol = new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty);
+        var symbol = new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty);
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
@@ -58,11 +58,11 @@ public void StructIdentifierIsVisitedAsIdentifier()
     [Fact]
     public void StructMemberIsVisited()
     {
-        MemberSymbol member = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test1"));
-        var symbol = new StructSymbol(new IdentifierSymbol("Test"), (new[]
+        MemberSymbol member = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty), new IdentifierSymbol("Test1"));
+        var symbol = new StructSymbol(new IdentifierSymbol("Test"), new StructLayout((new[]
         {
-            member
-        }).ToImmutableArray());
+            new LayoutEntry(member, 0)
+        }).ToImmutableArray()));
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true
@@ -77,13 +77,13 @@ public void StructMemberIsVisited()
     [Fact]
     public void StructMembersAreVisited()
     {
-        MemberSymbol member1 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test1"));
-        MemberSymbol member2 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test2"));
-        var symbol = new StructSymbol(new IdentifierSymbol("Test"), (new[]
+        MemberSymbol member1 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty), new IdentifierSymbol("Test1"));
+        MemberSymbol member2 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty), new IdentifierSymbol("Test2"));
+        var symbol = new StructSymbol(new IdentifierSymbol("Test"), new StructLayout((new[]
         {
-            member1,
-            member2
-        }).ToImmutableArray());
+            new LayoutEntry(member1, 0),
+            new LayoutEntry(member2, 4)
+        }).ToImmutableArray()));
         var visitor = new Mock<SymbolVisitor>
         {
             CallBase = true

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ public sealed class EmitterFieldIntegrationTests : EmitterTest`
`12`	`12`	`[Fact]`
`13`	`13`	`public void StructHasStructKeyword()`
`14`	`14`	`{`
`15`		`- var syntax = Transform(new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test")));`
	`15`	`+ var syntax = Transform(new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"),StructLayout.Empty), new IdentifierSymbol("Test")));`
`16`	`16`
`17`	`17`	`var result = syntax.ToFullString();`
`18`	`18`	`Assert.Equal("public int Test;", result);`
Original file line number	Diff line number	Diff line change
`@@ -13,28 +13,28 @@ public sealed class EmitterStructTests : EmitterTest`
`13`	`13`	`[Fact]`
`14`	`14`	`public void StructIsStructSyntax()`
`15`	`15`	`{`
`16`		`- var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty));`
	`16`	`+ var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty));`
`17`	`17`	`Assert.IsType<StructDeclarationSyntax>(syntax);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`[Fact]`
`21`	`21`	`public void StructHasStructKeyword()`
`22`	`22`	`{`
`23`		`- var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)) as StructDeclarationSyntax;`
	`23`	`+ var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)) as StructDeclarationSyntax;`
`24`	`24`	`Assert.Equal("struct", syntax!.Keyword.Text);`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`[Fact]`
`28`	`28`	`public void StructHasCorrectIdentifier()`
`29`	`29`	`{`
`30`		`- var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)) as StructDeclarationSyntax;`
	`30`	`+ var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)) as StructDeclarationSyntax;`
`31`	`31`	`Assert.Equal("Test", syntax!.Identifier.Text);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`[Fact]`
`35`	`35`	`public void StructIsOnlyPublic()`
`36`	`36`	`{`
`37`		`- var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)) as StructDeclarationSyntax;`
	`37`	`+ var syntax = Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)) as StructDeclarationSyntax;`
`38`	`38`	`var @public = Assert.Single(syntax!.Modifiers);`
`39`	`39`	`Assert.Equal("public", @public.Text);`
`40`	`40`	`}`
`@@ -43,8 +43,9 @@ public void StructIsOnlyPublic()`
`43`	`43`	`public void IntegrationEmptyStruct()`
`44`	`44`	`{`
`45`	`45`	`// Note that this test also covers trivia, which is not checked otherwise.`
`46`		`- Assert.Equal(@"public struct Test`
	`46`	`+ Assert.Equal(@"[StructLayout(LayoutKind.Explicit)]`
	`47`	`+public struct Test`
`47`	`48`	`{`
`48`		`-}", Transform(new StructSymbol(new IdentifierSymbol("Test"), ImmutableArray<MemberSymbol>.Empty)).ToFullString());`
	`49`	`+}", Transform(new StructSymbol(new IdentifierSymbol("Test"), StructLayout.Empty)).ToFullString());`
`49`	`50`	`}`
`50`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public class FieldTests`
`13`	`13`	`[Fact]`
`14`	`14`	`public void FieldIsVisitedAsField()`
`15`	`15`	`{`
`16`		`- var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));`
	`16`	`+ var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));`
`17`	`17`	`var visitor = new Mock<SymbolVisitor>`
`18`	`18`	`{`
`19`	`19`	`CallBase = true`
`@@ -28,7 +28,7 @@ public void FieldIsVisitedAsField()`
`28`	`28`	`[Fact]`
`29`	`29`	`public void FieldIsVisitedAsMember()`
`30`	`30`	`{`
`31`		`- var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));`
	`31`	`+ var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));`
`32`	`32`	`var visitor = new Mock<SymbolVisitor>`
`33`	`33`	`{`
`34`	`34`	`CallBase = true`
`@@ -43,7 +43,7 @@ public void FieldIsVisitedAsMember()`
`43`	`43`	`[Fact]`
`44`	`44`	`public void FieldTypeIsVisited()`
`45`	`45`	`{`
`46`		`- var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));`
	`46`	`+ var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));`
`47`	`47`	`var visitor = new Mock<SymbolVisitor>`
`48`	`48`	`{`
`49`	`49`	`CallBase = true`
`@@ -58,7 +58,7 @@ public void FieldTypeIsVisited()`
`58`	`58`	`[Fact]`
`59`	`59`	`public void FieldIdentifierIsVisited()`
`60`	`60`	`{`
`61`		`- var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol(""));`
	`61`	`+ var symbol = new FieldSymbol(new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty), new IdentifierSymbol(""));`
`62`	`62`	`var visitor = new Mock<SymbolVisitor>`
`63`	`63`	`{`
`64`	`64`	`CallBase = true`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public class StructTests`
`13`	`13`	`[Fact]`
`14`	`14`	`public void StructSymbolIsVisitedAsType()`
`15`	`15`	`{`
`16`		`- var symbol = new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty);`
	`16`	`+ var symbol = new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty);`
`17`	`17`	`var visitor = new Mock<SymbolVisitor>`
`18`	`18`	`{`
`19`	`19`	`CallBase = true`
`@@ -28,7 +28,7 @@ public void StructSymbolIsVisitedAsType()`
`28`	`28`	`[Fact]`
`29`	`29`	`public void StructSymbolIsVisitedAsStruct()`
`30`	`30`	`{`
`31`		`- var symbol = new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty);`
	`31`	`+ var symbol = new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty);`
`32`	`32`	`var visitor = new Mock<SymbolVisitor>`
`33`	`33`	`{`
`34`	`34`	`CallBase = true`
`@@ -43,7 +43,7 @@ public void StructSymbolIsVisitedAsStruct()`
`43`	`43`	`[Fact]`
`44`	`44`	`public void StructIdentifierIsVisitedAsIdentifier()`
`45`	`45`	`{`
`46`		`- var symbol = new StructSymbol(new IdentifierSymbol(""), ImmutableArray<MemberSymbol>.Empty);`
	`46`	`+ var symbol = new StructSymbol(new IdentifierSymbol(""), StructLayout.Empty);`
`47`	`47`	`var visitor = new Mock<SymbolVisitor>`
`48`	`48`	`{`
`49`	`49`	`CallBase = true`
`@@ -58,11 +58,11 @@ public void StructIdentifierIsVisitedAsIdentifier()`
`58`	`58`	`[Fact]`
`59`	`59`	`public void StructMemberIsVisited()`
`60`	`60`	`{`
`61`		`- MemberSymbol member = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test1"));`
`62`		`- var symbol = new StructSymbol(new IdentifierSymbol("Test"), (new[]`
	`61`	`+ MemberSymbol member = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty), new IdentifierSymbol("Test1"));`
	`62`	`+ var symbol = new StructSymbol(new IdentifierSymbol("Test"), new StructLayout((new[]`
`63`	`63`	`{`
`64`		`- member`
`65`		`- }).ToImmutableArray());`
	`64`	`+ new LayoutEntry(member, 0)`
	`65`	`+ }).ToImmutableArray()));`
`66`	`66`	`var visitor = new Mock<SymbolVisitor>`
`67`	`67`	`{`
`68`	`68`	`CallBase = true`
`@@ -77,13 +77,13 @@ public void StructMemberIsVisited()`
`77`	`77`	`[Fact]`
`78`	`78`	`public void StructMembersAreVisited()`
`79`	`79`	`{`
`80`		`- MemberSymbol member1 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test1"));`
`81`		`- MemberSymbol member2 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), ImmutableArray<MemberSymbol>.Empty), new IdentifierSymbol("Test2"));`
`82`		`- var symbol = new StructSymbol(new IdentifierSymbol("Test"), (new[]`
	`80`	`+ MemberSymbol member1 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty), new IdentifierSymbol("Test1"));`
	`81`	`+ MemberSymbol member2 = new FieldSymbol(new StructSymbol(new IdentifierSymbol("int"), StructLayout.Empty), new IdentifierSymbol("Test2"));`
	`82`	`+ var symbol = new StructSymbol(new IdentifierSymbol("Test"), new StructLayout((new[]`
`83`	`83`	`{`
`84`		`- member1,`
`85`		`- member2`
`86`		`- }).ToImmutableArray());`
	`84`	`+ new LayoutEntry(member1, 0),`
	`85`	`+ new LayoutEntry(member2, 4)`
	`86`	`+ }).ToImmutableArray()));`
`87`	`87`	`var visitor = new Mock<SymbolVisitor>`
`88`	`88`	`{`
`89`	`89`	`CallBase = true`