Support constants

[petermorlion]

Is it possible to support constants when checking if a type references other types?

Consider this test:

var architecture = new ArchLoader().LoadAssemblies(
    typeof(Class1).Assembly,
    typeof(Names).Assembly
    ).Build();

var coreClasses = Types().That().ResideInAssembly(typeof(Class1).Assembly);
var nameClasses = Types().That().ResideInAssembly(typeof(Names).Assembly);

var rule = coreClasses 
    .Should()
    .NotDependOnAny(nameClasses );

rule.Check(architecture);

Given this code:

namespace ArchUnitSample
{
    public class Class1
    {
        public string Name = Names.JohnDoe;
    }
}

...

namespace ArchUnitSample2
{
    public static class Names
    {
        // With this code snippet, the architecture rule fails
        //public static string JohnDoe = "John Doe";

        // With this code snippet, the architecture rule doesn't fail
        public const string JohnDoe = "John Doe";
    }
}

The test fails when we use the static property but doesn't when we use the const. I'm aware of the underlying difference between constants and statics, so that may be the cause. But I feel this rule then lets a violation slip through. In my case, this could be fixed with #130 but still, I wonder if this can be fixed.

[mak638]

Hi @petermorlion,
thank you for your question. Unfortunately, we are running into limitations here due to the way the C# compiler handles constants compared to static properties: While for static properties a ldsfld IL instruction is generated to load the field value at runtime, for constants the C# compiler always inlines them during compile time. I.e., in your example the string "John Doe" is directly embedded into the Class1 assembly's IL code.

Since there is no way to override this compiler behaviour, we unfortunately cannot support constants when checking for type references (even if the usage of the const technically should be an architecture rule violation).