New type of expression (compile time constant) to use in attributes

[dmitry-bym]

Background and Motivation

Im not actualy sure what type of issue create, because i still don't know better implementation.
I want to have Expression inside attribute to use that in source generators. So due to the fact that we can use only constants in attributes we can't use Expression however this is useles what i need just expression itself. It will improve source generators experience
One example:

[AttributeUsage(AttributeTargets.Class)]
public class MyAttribute<T>(string Prop) : Attribute;

Usage

public class FirstOne
{
    public string Text { get; set; }
}

[My<FirstOne>(nameof(FirstOne.Text))]
public class Target

It’s very unpleasant to write like this and I would like a more elegant way. with intelliSence and types. So that you can catch type mismatches while writing the code, and not during the build

Proposed API

Proposal is to create some class which will be evaluated at compiled time end will be just a string.
Just public api, so its possible just to get a string

public readonly struct InlineExpression<TDelegate>(InlineExpression value)
{
    public string? Value { get; } = value;

    public override string ToString()
    {
        return Value ?? string.Empty;
    }
}

With implicit cast to strings

InlineExpression<Func<string, bool>> myExpression = str => string.IsNullOrEmpty(str);
string myStr = myExpression;

Ofc its not posible to convert to Expression or Compile, or create from string, it will cause compilation error,

string myStr = "str => string.IsNullOrEmpty(str)";
InlineExpression<Func<string, bool>> myExpression = myStr;

Usage Examples

public class MyAttribute([ThreatAsInlineExpression<Func<string, bool>>] string expression)

[My(str => string.IsNullOrEmpty(str))]
public class Target;

after compilation

[My("str => string.IsNullOrEmpty(str)")]
public class Target;

Alternative Designs

Or it could be just analizer

public class MyAttribute([InlineExpression<Func<string, bool>>] string expression)

[My("str => string.IsNullOrEmpty(str)")] // string with all syntax hints and etc.
public class Target;

after compilation same string

[My("str => string.IsNullOrEmpty(str)")]
public class Target;

Risks

Don't see any risk.

Connected to #343