Emik.SourceGenerators.TheSquareHole 1.1.2

Emik.SourceGenerators.TheSquareHole

"And up next, a cylinder. Hmm, I think that goes in... the square hole!"

Adds structural typing to C#. Made as a celebration for my 20th birthday on August 8th 2023.

This project has a dependency to Emik.Morsels, if you are building this project, refer to its README first.

• Why
• How
• Configure
• Contribute
• License

Why

Despite the presentation of the project, the project itself is treated very seriously and addresses a real-world problem.

When creating software, you are encouraged to write code that is easily extensible and reusable. Interfaces are a fantastic way of achieving this, often allowing you to reuse methods that take said interface as a parameter. Part of the problem however is having to juggle the signatures of each interface in your head.

If you are creating a type specifically to implement an interface, this isn't much of a problem, but if you want to maximize the re-usability of a type, particularly if you make a type whose purpose is fairly generic, then you may often sit thinking about each interface you may consider adding.

Languages like Scala solve this issue using Structural Typing. If a type has the same declaring members as an interface, then it derives it.

How

This source generator looks at every interface accessible from your assembly and determines whether it is able to implement the interface.

Empty interfaces, alongside attributes marked with ObsoleteAttribute are not considered part of the search, as these interfaces tend to function more like attributes, and should therefore be opt-in.

If the interface contains generics, then the source generator performs Type Substitution: It considers every type declared within any type, including itself. For instance, take a look at the following type:

public class A(int i);

The type A declares a method with a parameter int, with nothing else. Therefore the candidates are int and A.

This results in the source generator being extremely flexible, and accounts for every possible implementation. For instance:

public partial record Cylinder<T1, T2>(T1 Second)
{
    public int First => 0;
}

interface ISquare<out T1, out T2>
{
    T1 First { get; }

    T2 Second { get; }
}

...generates...

// <auto-generated/>
#nullable enable
partial record Cylinder<T1, T2> : global::ISquare<int, T1>,
    global::System.Numerics.IEqualityOperators<global::Cylinder<T1, T2>, global::Cylinder<T1, T2>, bool>
{
}

The hard upper limit for type substitution with generics are exactly 3 of them. This does not include generics which are self-constrained.

While this analyzer does perform a lot of tricks to squeeze performance, type substituion may be still too expensive on your machine. Refer to Configure in that case.

Configure

Use .editorconfig/.globalconfig to configure this source generator:

Contribute

Issues and pull requests are welcome to help this repository be the best it can be.

License

This repository falls under the MPL-2 license.