Add first-class runtime type constraint definitions and separate type-constraint registration (#144)

Author: Copilot

src/MLIR/Dialects/Dialect.cs

@@ -15,13 +15,15 @@ namespace MLIR.Dialects;
 /// <param name="types">The type definitions exported by the dialect.</param>
 /// <param name="attributeConstraints">The context-directed attribute constraint definitions exported by the dialect.</param>
 /// <param name="dependencies">Dialect registrations that must be registered before this one.</param>
+/// <param name="typeConstraints">The context-directed type constraint definitions exported by the dialect.</param>
 public sealed class Dialect(
     string name,
     IReadOnlyList<OperationDefinition> operations,
     IReadOnlyList<AttributeDefinition>? attributes = null,
     IReadOnlyList<TypeDefinition>? types = null,
     IReadOnlyList<AttributeConstraintDefinition>? attributeConstraints = null,
-    IReadOnlyList<Func<Dialect>>? dependencies = null)
+    IReadOnlyList<Func<Dialect>>? dependencies = null,
+    IReadOnlyList<TypeConstraintDefinition>? typeConstraints = null)
 {
     /// <summary>
     /// Creates a dialect from a fluent builder callback.
@@ -62,6 +64,11 @@ public static Dialect Create(string name, Action<DialectBuilder> configure, para
     /// </summary>
     public IReadOnlyList<TypeDefinition> Types { get; } = types ?? EmptyTypes;
 
+    /// <summary>
+    /// Gets the context-directed type constraint definitions exported by the dialect.
+    /// </summary>
+    public IReadOnlyList<TypeConstraintDefinition> TypeConstraints { get; } = typeConstraints ?? EmptyTypeConstraints;
+
     /// <summary>
     /// Gets the dialect registrations that must be registered before this dialect.
     /// </summary>
@@ -70,5 +77,6 @@ public static Dialect Create(string name, Action<DialectBuilder> configure, para
     private static readonly IReadOnlyList<AttributeDefinition> EmptyAttributes = new AttributeDefinition[0];
     private static readonly IReadOnlyList<AttributeConstraintDefinition> EmptyAttributeConstraints = new AttributeConstraintDefinition[0];
     private static readonly IReadOnlyList<TypeDefinition> EmptyTypes = new TypeDefinition[0];
+    private static readonly IReadOnlyList<TypeConstraintDefinition> EmptyTypeConstraints = new TypeConstraintDefinition[0];
     private static readonly IReadOnlyList<Func<Dialect>> EmptyDependencies = new Func<Dialect>[0];
 }

src/MLIR/Dialects/DialectBuilder.cs

@@ -13,6 +13,7 @@ public sealed class DialectBuilder
     private readonly List<AttributeDefinition> attributes = new List<AttributeDefinition>();
     private readonly List<AttributeConstraintDefinition> attributeConstraints = new List<AttributeConstraintDefinition>();
     private readonly List<TypeDefinition> types = new List<TypeDefinition>();
+    private readonly List<TypeConstraintDefinition> typeConstraints = new List<TypeConstraintDefinition>();
     private readonly List<Func<Dialect>> dependencies = new List<Func<Dialect>>();
 
     /// <summary>
@@ -71,6 +72,15 @@ public DialectBuilder AddType(TypeDefinition type)
         return this;
     }
 
+    /// <summary>
+    /// Adds a type constraint definition.
+    /// </summary>
+    public DialectBuilder AddTypeConstraint(TypeConstraintDefinition typeConstraint)
+    {
+        typeConstraints.Add(typeConstraint);
+        return this;
+    }
+
     /// <summary>
     /// Adds a dialect registration dependency.
     /// </summary>
@@ -85,6 +95,6 @@ public DialectBuilder AddDependency(Func<Dialect> dependency)
     /// </summary>
     public Dialect Build(IReadOnlyList<Func<Dialect>>? dependencies = null)
     {
-        return new Dialect(name, operations, attributes, types, attributeConstraints, dependencies ?? this.dependencies);
+        return new Dialect(name, operations, attributes, types, attributeConstraints, dependencies ?? this.dependencies, typeConstraints);
     }
 }

src/MLIR/Dialects/DialectRegistry.cs

@@ -14,6 +14,7 @@ public sealed class DialectRegistry
     private readonly Dictionary<string, AttributeDefinition> attributesByParserName = new Dictionary<string, AttributeDefinition>(StringComparer.Ordinal);
     private readonly Dictionary<string, AttributeConstraintDefinition> attributeConstraintsByName = new Dictionary<string, AttributeConstraintDefinition>(StringComparer.Ordinal);
     private readonly Dictionary<string, TypeDefinition> typesByName = new Dictionary<string, TypeDefinition>(StringComparer.Ordinal);
+    private readonly Dictionary<string, TypeConstraintDefinition> typeConstraintsByName = new Dictionary<string, TypeConstraintDefinition>(StringComparer.Ordinal);
 
     /// <summary>
     /// Gets the dialects currently registered in the registry.
@@ -90,6 +91,25 @@ private void RegisterDialect(Dialect dialect, bool isDependency)
             {
                 throw new ArgumentException($"The type '{type.Name}' is already registered.", nameof(dialect));
             }
+
+            if (typeConstraintsByName.ContainsKey(type.Name))
+            {
+                throw new ArgumentException($"The type constraint '{type.Name}' is already registered.", nameof(dialect));
+            }
+        }
+
+        foreach (var typeConstraint in dialect.TypeConstraints)
+        {
+            var constraintName = typeConstraint.Name;
+            if (constraintName != null && typeConstraintsByName.ContainsKey(constraintName))
+            {
+                throw new ArgumentException($"The type constraint '{constraintName}' is already registered.", nameof(dialect));
+            }
+
+            if (constraintName != null && typesByName.ContainsKey(constraintName))
+            {
+                throw new ArgumentException($"The type '{constraintName}' is already registered.", nameof(dialect));
+            }
         }
 
         dialectsByName.Add(dialect.Name, dialect);
@@ -120,6 +140,16 @@ private void RegisterDialect(Dialect dialect, bool isDependency)
         foreach (var type in dialect.Types)
         {
             typesByName.Add(type.Name, type);
+            typeConstraintsByName.Add(type.Name, type);
+        }
+
+        foreach (var typeConstraint in dialect.TypeConstraints)
+        {
+            var constraintName = typeConstraint.Name;
+            if (constraintName != null)
+            {
+                typeConstraintsByName.Add(constraintName, typeConstraint);
+            }
         }
     }
 
@@ -201,4 +231,12 @@ public bool TryGetType(string name, out TypeDefinition type)
     {
         return typesByName.TryGetValue(name, out type!);
     }
+
+    /// <summary>
+    /// Tries to resolve a type constraint definition by name.
+    /// </summary>
+    public bool TryResolveTypeConstraint(string name, out TypeConstraintDefinition typeConstraint)
+    {
+        return typeConstraintsByName.TryGetValue(name, out typeConstraint!);
+    }
 }

src/MLIR/Dialects/TypeConstraintDefinition.cs

@@ -0,0 +1,26 @@
+namespace MLIR.Dialects;
+
+using MLIR.Semantics;
+
+/// <summary>
+/// Describes a context-directed type constraint (<c>Type</c> in ODS) that can parse and bind type references.
+/// </summary>
+/// <remarks>
+/// Initializes a new instance of the <see cref="TypeConstraintDefinition"/> class.
+/// </remarks>
+/// <param name="name">The logical constraint name, if one is known.</param>
+/// <param name="assemblyFormat">The optional custom assembly interpretation hook.</param>
+public class TypeConstraintDefinition(
+    string? name = null,
+    ITypeAssemblyFormat? assemblyFormat = null)
+{
+    /// <summary>
+    /// Gets the logical constraint name, if one is known.
+    /// </summary>
+    public string? Name { get; } = name;
+
+    /// <summary>
+    /// Gets the custom assembly interpretation hook, if one is registered.
+    /// </summary>
+    public ITypeAssemblyFormat? AssemblyFormat { get; } = assemblyFormat;
+}

src/MLIR/Dialects/TypeDefinition.cs

@@ -3,9 +3,13 @@ namespace MLIR.Dialects;
 using MLIR.Semantics;
 
 /// <summary>
-/// Describes a dialect-defined type.
+/// Describes a concrete dialect-defined type (<c>TypeDef</c> in ODS).
 /// </summary>
 /// <remarks>
+/// Concrete type definitions are also valid type constraints, so this class derives from
+/// <see cref="TypeConstraintDefinition"/>.
+/// </remarks>
+/// <remarks>
 /// Initializes a new instance of the <see cref="TypeDefinition"/> class.
 /// </remarks>
 /// <param name="name">The canonical type name.</param>
@@ -15,16 +19,16 @@ public sealed class TypeDefinition(
     string name,
     ITypeAssemblyFormat? assemblyFormat = null,
     System.Func<TypeReferenceConstructionContext, TypeReference>? factory = null)
+    : TypeConstraintDefinition(name, assemblyFormat)
 {
     /// <summary>
     /// Gets the canonical type name.
     /// </summary>
-    public string Name { get; } = name;
-
-    /// <summary>
-    /// Gets the custom assembly interpretation hook, if one is registered.
-    /// </summary>
-    public ITypeAssemblyFormat? AssemblyFormat { get; } = assemblyFormat;
+    /// <remarks>
+    /// This narrows <see cref="TypeConstraintDefinition.Name"/> back to a non-null contract for
+    /// concrete <c>TypeDef</c> registrations.
+    /// </remarks>
+    public new string Name { get; } = name;
 
     /// <summary>
     /// Gets the typed type-reference factory.

tests/MLIR.Tests/SemanticRegistryTests.cs

@@ -31,4 +31,25 @@ public void RegistryRejectsDuplicateAttributeAndTypeRegistrations()
         Assert.Contains("already registered", attributeException.Message);
         Assert.Contains("already registered", typeException.Message);
     }
+
+    [Fact]
+    public void RegistryResolvesStandaloneAndConcreteTypeConstraints()
+    {
+        var registry = new DialectRegistry();
+        var standaloneConstraint = new TypeConstraintDefinition("AnyType");
+        var concreteType = new TypeDefinition("i32");
+        registry.RegisterDialect(new Dialect("builtin", [], [], [concreteType], [], [], [standaloneConstraint]));
+
+        Assert.True(registry.TryResolveTypeConstraint("AnyType", out var resolvedStandaloneConstraint));
+        Assert.Same(standaloneConstraint, resolvedStandaloneConstraint);
+
+        Assert.True(registry.TryResolveTypeConstraint("i32", out var resolvedConcreteConstraint));
+        Assert.Same(concreteType, resolvedConcreteConstraint);
+        Assert.IsType<TypeDefinition>(resolvedConcreteConstraint);
+
+        Assert.True(registry.TryGetType("i32", out var resolvedConcreteType));
+        Assert.Same(concreteType, resolvedConcreteType);
+
+        Assert.False(registry.TryGetType("AnyType", out _));
+    }
 }