a common abstract view on the bound trees of the C# and VB compilers, and extends the analyzers API to include operation actions that operate upon them.
It is now possible to write a single analyzer that works for both C# and VB, so long as the analyzer operates entirely within semantic realms.

        /// <summary>
        /// Assertion for the argument value
        /// </summary>
        [DebuggerHidden]
        [AssertionMethod, StringFormatMethod("messageFormat")]
        public static void AssertArgument(
            [AssertionCondition(AssertionConditionType.IS_TRUE)] bool condition,
            [NotNull] [InvokerParameterName] string argName,
            [NotNull] string messageFormat,
            [CanBeNull] params object[] args)
        {
            if (!condition)
                throw CodeExceptions.Argument(argName, messageFormat, args);
        }

string GetOrDefault(string? nullable) => nullable ?? "N/A"; // OK

string GetOrDefault(string? nullable) => nullable;          // Compiler warning

string GetOrDefault(string nullable) => nullable ?? "N/A";  // Compiler warning (unreachable code)

ContractAnnotation("value:null => halt")

ContractAnnotation("condition:false => halt")

/// <summary>
/// Assertion for the argument value
/// </summary>
[DebuggerHidden]
[AssertionMethod, StringFormatMethod("messageFormat")]
public static void AssertArgument(
        [AssertionCondition(AssertionConditionType.IS_TRUE)] bool condition,
        [NotNull] [InvokerParameterName] string argName,
        [NotNull] string messageFormat,
        [CanBeNull] params object[] args)
{
        if (!condition)
                throw CodeExceptions.Argument(argName, messageFormat, args);
}

R>/// <summary>
R>/// Assertion for the argument value
R>/// </summary>
R>[DebuggerHidden]
R>[AssertionMethod, StringFormatMethod("messageFormat")]
R>public static void AssertArgument(
R>        [AssertionCondition(AssertionConditionType.IS_TRUE)] bool condition,
R>        [NotNull] [InvokerParameterName] string argName,
R>        [NotNull] string messageFormat,
R>        [CanBeNull] params object[] args)
R>{
R>        if (!condition)
R>                throw CodeExceptions.Argument(argName, messageFormat, args);
R>}
R>

  Foo() : void
    requires i >= 0 && i < 5
  {
    def x = array[1,2,3,4];
    WriteLine(x[i]);
  }

  GetFoo(i : int) : int
    requires i >= 0 && i < 5 otherwise throw ArgumentOutOfRangeException(i.ToString())
  {
    def x = array[1, 2, 3, 4];
    WriteLine(x[i]);
    x [i]
  }
  
  
  Boo(x : int) : void
    ensures i >= 0 && i < 5
  {
    i = x;
    WriteLine(x);
  }

C>Тенденция намечается интересная, так, глядишь, лет через несколько design by types в мейнстриме увидим как модную парадигму программирования.
...
Если я конечно правильно тебя понял и речь про AOP-хардкор с накидыванием большей части поведения через кучу атрибутов.
Как пример к чему оно приводит: