Add unit tests for generated IOperationAssemblyFormat.Bind implementations

tests/DialectTests/DialectIntegrationTests.cs

@@ -3,6 +3,8 @@ namespace DialectTests;
 using MLIR;
 using MLIR.Dialects;
 using MLIR.Miniarith;
+using MLIR.Semantics;
+using MLIR.Syntax;
 using Xunit;
 
 public sealed class DialectIntegrationTests
@@ -72,4 +74,99 @@ public void GeneratedDialectCanReadAndWriteBoundModules()
 
         Assert.Equal(source, module.ToText());
     }
+
+    [Fact]
+    public void GeneratedAssemblyFormatBindProducesTypedAddIOpFromCustomBodySyntax()
+    {
+        // Arrange: construct a custom body matching "$lhs `,` $rhs attr-dict `:` type($result)"
+        var body = new MiniArith_AddIOpBodySyntax(
+            new SyntaxToken("%lhs"),
+            new SyntaxToken(","),
+            new SyntaxToken("%rhs"),
+            new DelimitedSyntaxList<NamedAttributeSyntax>(null, [], [], null),
+            new SyntaxToken(":"),
+            new RawTypeSyntax(new RawSyntaxText("i32")));
+
+        var syntax = new OperationSyntax(
+            resultTokens: [new SyntaxToken("%result")],
+            resultCommaTokens: [],
+            equalsToken: new SyntaxToken("="),
+            nameToken: new SyntaxToken("miniarith.addi"),
+            body: body);
+
+        var registry = new DialectRegistry();
+        registry.RegisterDialect(MiniarithDialectRegistration.Create());
+
+        // Act: bind invokes MiniArith_AddIOpAssemblyFormat.Bind because body is not GenericOperationBodySyntax
+        var module = Binder.BindModule(new ModuleSyntax([syntax]), registry);
+
+        // Assert
+        Assert.Empty(module.AssemblyDiagnostics);
+        var operation = Assert.IsType<MiniArith_AddIOp>(Assert.Single(module.Operations));
+        Assert.Equal("miniarith.addi", operation.Name);
+        Assert.Equal("%lhs", operation.Lhs.Name);
+        Assert.Equal("%rhs", operation.Rhs.Name);
+        Assert.Equal("%result", operation.ResultValue.Name);
+        Assert.NotNull(operation.TypeSignatureReference);
+    }
+
+    [Fact]
+    public void GeneratedAssemblyFormatBindProducesTypedConstantOpFromCustomBodySyntax()
+    {
+        // Arrange: construct a custom body matching "$value attr-dict"
+        var body = new MiniArith_ConstantOpBodySyntax(
+            new RawAttributeValueSyntax(new RawSyntaxText("42")),
+            new DelimitedSyntaxList<NamedAttributeSyntax>(null, [], [], null));
+
+        var syntax = new OperationSyntax(
+            resultTokens: [new SyntaxToken("%result")],
+            resultCommaTokens: [],
+            equalsToken: new SyntaxToken("="),
+            nameToken: new SyntaxToken("miniarith.constant"),
+            body: body);
+
+        var registry = new DialectRegistry();
+        registry.RegisterDialect(MiniarithDialectRegistration.Create());
+
+        // Act: bind invokes MiniArith_ConstantOpAssemblyFormat.Bind because body is not GenericOperationBodySyntax
+        var module = Binder.BindModule(new ModuleSyntax([syntax]), registry);
+
+        // Assert
+        Assert.Empty(module.AssemblyDiagnostics);
+        var operation = Assert.IsType<MiniArith_ConstantOp>(Assert.Single(module.Operations));
+        Assert.Equal("miniarith.constant", operation.Name);
+        Assert.Equal("%result", operation.ResultValue.Name);
+        Assert.Equal("value", operation.Value.Name);
+        Assert.Null(operation.TypeSignatureReference);
+    }
+
+    [Fact]
+    public void GeneratedAssemblyFormatBindReportsDiagnosticForWrongResultCount()
+    {
+        // Arrange: zero result tokens when the operation expects exactly one
+        var body = new MiniArith_AddIOpBodySyntax(
+            new SyntaxToken("%lhs"),
+            new SyntaxToken(","),
+            new SyntaxToken("%rhs"),
+            new DelimitedSyntaxList<NamedAttributeSyntax>(null, [], [], null),
+            new SyntaxToken(":"),
+            new RawTypeSyntax(new RawSyntaxText("i32")));
+
+        var syntax = new OperationSyntax(
+            resultTokens: [],
+            resultCommaTokens: [],
+            equalsToken: null,
+            nameToken: new SyntaxToken("miniarith.addi"),
+            body: body);
+
+        var registry = new DialectRegistry();
+        registry.RegisterDialect(MiniarithDialectRegistration.Create());
+
+        // Act
+        var module = Binder.BindModule(new ModuleSyntax([syntax]), registry);
+
+        // Assert: one diagnostic reported, operation is uninterpreted
+        Assert.Single(module.AssemblyDiagnostics);
+        Assert.IsType<UninterpretedOperation>(Assert.Single(module.Operations));
+    }
 }