Make a class implementing an interface

[YBAZAN]

Hello,

I'm wondering if it's possible from a MethodAspect to make the declaring class implementing an interface.

Here my code:

Source code

public interface IObject {}
public interface IHandleObject<TObject> where TObject : IObject
{
   void Handle(TObject instance);
}

internal class Program
{
    [ObjectHandler]
    public void Handle(Object1 instance)
    {
    }

    public class Object1 : IObject { }
}

Aspect code

using Metalama.Framework.Aspects;
using Metalama.Framework.Code;
using Metalama.Framework.Code.Collections;

public class ObjectHandler : MethodAspect
{
    /// <inheritdoc />
    public override void BuildAspect(IAspectBuilder<IMethod> builder)
    {
        base.BuildAspect(builder);

        var interfaceType =
            typeof(IHandleObject<>).MakeGenericType(builder.Target.Parameters.OfName("instance")!.Type.ToType());
        builder.Advice.ImplementInterface(builder.Target.DeclaringType, interfaceType);
    }
}

I would expect that the aspect adds IHandleObject<Object1> to the Program class but I get this error:
Program.cs(9,17): error LAMA0041: 'ObjectHandler.BuildAspect' threw 'NotSupportedException' when applied to 'Program.Handle(Program.Object1)': Derived classes must provide an implementation.

Is there something I'm doing wrong or such scenario is not supported by Metalama?

[svick]

Hi.

That particular exception happens because usage of Type in aspects is limited. Instead, you have to use TypeFactory and work with IType.

The fundamental problem though, is that implementing an interface whose members have "unknown" types is currently not supported. The closest you can get right now is: (Try Metalama link)

public class ObjectHandler : MethodAspect
{
    public override void BuildAspect(IAspectBuilder<IMethod> builder)
    {
        base.BuildAspect(builder);

        var interfaceType =
            ((INamedType)TypeFactory.GetType(typeof(IHandleObject<>))).WithTypeArguments(builder.Target.Parameters.OfName("instance")!.Type);
        builder.Advice.ImplementInterface(builder.Target.DeclaringType, interfaceType);
    }

    [InterfaceMember(IsExplicit = true)]
    internal void Handle(Program.Object1 instance) => meta.This.Handle(instance);
}

But that's obviously not what you want, since it requires that the aspect knows the type Object1 from the target code.

We plan to support this scenario in a future version of Metalama.