declaring type of virtual property does not match to type of lambda parameter

[habib-sadullaev]

Version Used: Version: 3.1.9 Commit: 774fc3d6a9

Steps to Reproduce:

using System;
using System.Linq.Expressions;

abstract class Base { public abstract int Value { get; set; } }
class Derived : Base { public override int Value { get; set; } }

static bool PropertyBelongsToParameter(Expression<Func<Derived, int>> expr)
{
    var type = (expr.Body as MemberExpression).Member.DeclaringType;

    return type == expr.Parameters[0].Type;
}

PropertyBelongsToParameter(x => x.Value);

Expected Behavior: returns true

Actual Behavior: returns false

PropertyBelongsToParameterIssue.zip

[CyrusNajmabadi]

Closing out as the behavior seems correct to me. . Member.DeclaringType would be Base, and the parameter type would be Derived.

[habib-sadullaev]

but according to https://docs.microsoft.com/en-us/dotnet/api/system.reflection.memberinfo.declaringtype?view=netcore-3.1
and if we check this

  typeof(Derived).GetProperty(nameof(Derived.Value)).DeclaringType = typeof(Derived)

we'll get true

[habib-sadullaev]

and another example - if we manually create this expression PropertyBelongsToParameter will return true

//workaround
var param = Expression.Parameter(typeof(Derived), "x");
var body = Expression.Property(param, nameof(Derived.Value));
var expr = Expression.Lambda<Func<Derived, int>>(body, param);

PropertyBelongsToParameter(expr); //returns true

[CyrusNajmabadi]

typeof(Derived).GetProperty(nameof(Derived.Value)).DeclaringType = typeof(Derived)

Yes. because you're asking the decraring type of Derived.Value there. THat's not what C# has there. When you access x.Value in x => x.Value then .Value is accessing Base.Value. This is how the language is specified. Virtual access calls through to the actual original member definition, not the override.

[CyrusNajmabadi]

Note: you can see this clearly in the IL produced:

	IL_000e: ldtoken ConsoleApp6.Derived
	IL_0013: call class [System.Runtime]System.Type [System.Runtime]System.Type::GetTypeFromHandle(valuetype [System.Runtime]System.RuntimeTypeHandle)
	IL_0018: ldstr "x"
	IL_001d: call class [System.Linq.Expressions]System.Linq.Expressions.ParameterExpression [System.Linq.Expressions]System.Linq.Expressions.Expression::Parameter(class [System.Runtime]System.Type, string)
	IL_0022: stloc.1
	IL_0023: ldloc.1
	IL_0024: ldtoken method instance int32 ConsoleApp6.Base::get_Value()  //<-- here
	IL_0029: call class [System.Runtime]System.Reflection.MethodBase [System.Runtime]System.Reflection.MethodBase::GetMethodFromHandle(valuetype [System.Runtime]System.RuntimeMethodHandle)
	IL_002e: castclass [System.Runtime]System.Reflection.MethodInfo
	IL_0033: call class [System.Linq.Expressions]System.Linq.Expressions.MemberExpression [System.Linq.Expressions]System.Linq.Expressions.Expression::Property(class [System.Linq.Expressions]System.Linq.Expressions.Expression, class [System.Runtime]System.Reflection.MethodInfo)
	IL_0038: ldc.i4.1
	IL_0039: newarr [System.Linq.Expressions]System.Linq.Expressions.ParameterExpression

We're getting the method given the handle for Base.get_Value() (the get accessor for the Value property).

[habib-sadullaev]

Thanks for explanation.
But it's not clear how we can get the same result if I create this expression manually:

var param = Expression.Parameter(typeof(Derived), "x");
var prop = typeof(Base).GetProperty("Value");
var body = Expression.Property(param, prop);
var expr = Expression.Lambda<Func<Derived, int>>(body, param);

instead of doing as i did

var param = Expression.Parameter(typeof(Derived), "x");
var body = Expression.Property(param, "Value");
var expr = Expression.Lambda<Func<Derived, int>>(body, param);

It's confusing. I think, this is inconsistency between lambda form and manually created one or am I wrong?

[CyrusNajmabadi]

But it's not clear how we can get the same result if I create this expression manually:

If you create it manually like that, what happens?

[habib-sadullaev]

i expect to get the same result, but it's not the same

[CyrusNajmabadi]

i expect to get the same result

The same result as what? What two things do you expect to be equivalent?

[habib-sadullaev]

The same result as what? What two things do you expect to be equivalent?

I expect that PropertyBelongsToParameter is true for both

x => x.Value

and

var param = Expression.Parameter(typeof(Derived), "x");
var body = Expression.Property(param, "Value");
var expr = Expression.Lambda<Func<Derived, int>>(body, param);

but it's not what I exactly need.
I have a code:

using System;
using System.Linq.Expressions;

public class RewriteAttribute : Attribute { }
public class Base { public virtual int Value { get; set; } }
public class Derived : Base {[Rewrite] public override int Value { get; set; } }
public class Rewriter : ExpressionVisitor
{
    protected override Expression VisitMember(MemberExpression node)
    {
        //if (node.Member.IsDefined(typeof(RewriteAttribute), inherit: false)) <-- doesnt work
        if (node.Expression.Type.GetProperty(node.Member.Name).IsDefined(typeof(RewriteAttribute), inherit: false))
        {
            return Rewrite(node);
        }

        return base.VisitMember(node);
    }

    private Expression Rewrite(MemberExpression node)
    {
        throw new NotImplementedException();
    }
}

instead of this node.Member.IsDefined(typeof(RewriteAttribute), inherit: false) I need to use following
node.Expression.Type.GetProperty(node.Member.Name).IsDefined(typeof(RewriteAttribute), inherit: false) that looks like workaround.

[CyrusNajmabadi]

I expect that PropertyBelongsToParameter is true for both

x => x.Value

As mentioned, this is an incorrect expectation. This is not how the language works. You can look at the actual IL for just calling x.Value or look at the IL for the expression tree. Virtual calls go to the base virtual, not the derived override.

[habib-sadullaev]

Thank you for your patience. Now it's clear that my expectations are wrong.

[CyrusNajmabadi]

Happy to help. We also have several community forums (where the team participates as well) to bounce ideas and questions off of. See: https://github.com/dotnet/roslyn#questions