Where T: NotInterface should be supported given that implicit operators cannot return an interface

[Triggs9]

Given this issue: dotnet/roslyn#47399

there should be a way to limit a generic from ever being an interface?

[YairHalberstadt]

What would be an example of code you would write if this was allowed?

[Triggs9]

public class UpCastableCommon: UpCastableBase
{
    
}

public class UpCastableDerivedTest<R>: OriUpCastBase<UpCastableCommon, R>
{
    
}

public abstract class OriUpCastBase<TCommon, TReturn>
where TCommon: UpCastableBase
{
    public TReturn Return { get; private set; }
    public TCommon Common { get; private set; }
    
    public static implicit operator TReturn(OriUpCastBase<TCommon, TReturn> incoming)
    {
        return incoming.Return;
    }
    
    public static implicit operator TCommon(OriUpCastBase<TCommon, TReturn> incoming)
    {
        return incoming.Common;
    }
}

public static class OriUpCastable<TCommon, TReturnWrapper, TReturn>
where TCommon: UpCastableBase
where TReturnWrapper: OriUpCastBase<TCommon, TReturn>
{
    public static TReturnWrapper UpCast(TCommon incomingWrapper)
    {
        return default;
    }    
}

UpCastableCommon test1 = new UpCastableCommon();
UpCastableDerivedTest<IList> test2 = new UpCastableDerivedTest<IList>();

List<string> test10 = OriUpCastable<UpCastableCommon,UpCastableDerivedTest<List<string>>, List<string>>.UpCast(test1);
IList test10 = OriUpCastable<UpCastableCommon,UpCastableDerivedTest<IList>, IList>.UpCast(test1); // this gives an invalid cast error as described by https://github.com/dotnet/roslyn/issues/47399
OriSettings test3 = OriUpCastable<UpCastableCommon,UpCastableDerivedTest<OriSettings>, OriSettings>.UpCast(test2);

this allows passing a single object around while storing data in properties that are dependent on the type its cast to through the same object, not fully fleshed out but I wanted to get the framework down first and it works, with this minor error (warning really)

[Triggs9]

i havent heard of an analyzer i should look into them. and i agree with the wrapper method, but in my case i have a wrapper class implemented instead

[YairHalberstadt]

For a very similar analyzer you could use to get you started check out https://github.com/Joe4evr/JiiLib/blob/master/src/JiiLib.Constraints/Analyzers/InterfacesOnly/InterfaceConstraintAnalyzer.cs

[YairHalberstadt]

@Joe4evr maybe one to add your library!

[Joe4evr]

NonAbstractOnly is technically closer to this, but NoInterfaces would be pretty simple to add. I'll start on it when I get home from work.

[Joe4evr]

@YairHalberstadt Mostly done: https://github.com/Joe4evr/JiiLib/blob/master/src/JiiLib.Constraints/Analyzers/NoInterfaces/NoInterfacesConstraintAnalyzer.cs
There's a couple things left for refinement, but the initial analyzer will be up in a minute.

[YairHalberstadt]

As a general rule, if you all you want to do is to make currently legal code illegal, roslyn analyzers are a great way to do that, and don't require language changes.

Language changes would only be considered for such things if by making certain code illegal, that allows us to do something new which is currently illegal, or if the use case is extremely common.

[Triggs9]

my argument is that you have an illegal constraint that was not fully implemented and constrained. in this case the inability of the language itself to return an interface through implicit casting and there should be more transparency as to what exactly is going wrong there and one of the best ways i can picture doing that is through where T: notinterface. I dont see it as such a far stretch from where T: notnull which is already implemented. My code works regardless I am merely pointing out a flaw I see so that future me doesn't have to dig through github to know why he can't implicitly return an interface. I am not arguing to change the entire structure of the csharp language itself

[YairHalberstadt]

Understood. In this case I think the error could definitely be improved, which should solve most of the issue.

[Triggs9]

Another very strong use case:

public class NavigationCarrier_Basic<O>: UpCastableCommon, INavigationCarrier_Basic<O>
{
    NavigationCarrier_Data<O> PreviousObject { get; set; }
    NavigationCarrier_Data<O> CurrentObject { get; set; }
}

public class NavigationCarrier_Basic<O, R>: OriUpCastBase<NavigationCarrier_Basic<O>, R>
{
    R Result { get; }
}

public abstract class OriGenericVisitor_TypeQualifier<O, N, R>: OriGenericVisitorBase<O, N>
where N: NavigationCarrier_Basic<O, R>, new()
{
    protected N Navigation(N){}

    protected bool Process(O incomingObjectToProcess)
    {
        ...
        N newN = new N();
        NavigationCarrier_Basic<O> castN = newN;
        castN.PreviousObject = new NavigationCarrier_Data<O>()
        {
            Data = incomingPreviousObject
        };
        castN.CurrentObject = new NavigationCarrier_Data<O>()
        {
            Data = incomingNextObject
        };
        N reforgedN = OriUpCastable<NavigationCarrier_Basic<O>, N, R>.UpCast(castN);

        NavigationCarrier_Basic<O, R> navigationResult = this.Navigation(reforgedN);
        ...
    }
}

implementing something like this using reflection is doable, but this is done at compiler time instead of runtime and is far more readable. id argue next gen reflection.

it would be nice if the intellisense was capable of doing something like this

N newN = new N(){
    PreviousObject = new NavigationCarrier_Data<O>()
    {
        Data = incomingPreviousObject
    };
    CurrentObject = new NavigationCarrier_Data<O>()
    {
        Data = incomingNextObject
    };
};

but its not