/// <summary>
/// Makes an expression slim representing a NewExpression with the given children.
/// </summary>
/// <param name="node">Original expression.</param>
/// <param name="arguments">Argument expression slims.</param>
/// <returns>Slim representation of the original expression.</returns>
protected override ExpressionSlim MakeNew(NewExpression node, ReadOnlyCollection <ExpressionSlim> arguments)
{
if (node.Constructor != null)
{
var constructor = MakeConstructor(node.Constructor);
var richMembers = node.Members;
var slimMembers = default(IList <MemberInfoSlim>);
if (richMembers != null)
{
var n = richMembers.Count;
slimMembers = new MemberInfoSlim[n];
for (var i = 0; i < n; i++)
{
slimMembers[i] = MakeMember(richMembers[i]);
}
}
return(_factory.New(constructor, arguments, slimMembers));
}
else
{
var type = MakeType(node.Type);
return(_factory.New(type));
}
}
public Json.Expression AddMember(MemberInfoSlim member)
{
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
if (!_members.TryGetValue(member, out int index))
{
var typeRef = AddType(member.DeclaringType);
var memberDef = member.MemberType switch
{
MemberTypes.Method => AddMethod(typeRef, (MethodInfoSlim)member),
MemberTypes.Constructor => AddConstructor(typeRef, (ConstructorInfoSlim)member),
MemberTypes.Field => new FieldDef(typeRef, (FieldInfoSlim)member),
MemberTypes.Property => new PropertyDef(typeRef, (PropertyInfoSlim)member),
_ => throw new NotSupportedException("Invalid member type."),
};
index = _members.Count;
_memberDefs.Add(memberDef);
_members.Add(member, index);
}
return(index.ToJsonNumber());
}
public static string GetName(this MemberInfoSlim m)
{
return(m switch
{
SimpleMethodInfoSlimBase smtd => smtd.Name,
GenericMethodInfoSlim gmtd => gmtd.GenericMethodDefinition.GetName(),
PropertyInfoSlim prp => prp.Name,
FieldInfoSlim fld => fld.Name,
_ => "<unknown>",
});
internal static MemberExpressionSlim Make(ExpressionSlim expression, MemberInfoSlim member)
{
if (expression == null)
{
return(new MemberExpressionSlim(member));
}
else
{
return(new InstanceMemberExpressionSlim(expression, member));
}
}
/// <summary>
/// Visits the specified member.
/// </summary>
/// <param name="member">Member to visit.</param>
/// <returns>Result of the visit.</returns>
public MemberInfoSlim Visit(MemberInfoSlim member)
{
if (member == null)
{
throw new ArgumentNullException(nameof(member));
}
return(member.MemberType switch
{
MemberTypes.Constructor => VisitConstructor((ConstructorInfoSlim)member),
MemberTypes.Field => VisitField((FieldInfoSlim)member),
MemberTypes.Method => VisitMethod((MethodInfoSlim)member),
MemberTypes.Property => VisitProperty((PropertyInfoSlim)member),
_ => throw new NotSupportedException("Unknown type kind."),
});
private static void AssertAreSame(MemberInfo member, MemberInfoSlim slimMember)
{
switch (slimMember.MemberType)
{
case MemberTypes.Constructor:
AssertAreSameConstructor((ConstructorInfo)member, (ConstructorInfoSlim)slimMember);
return;
case MemberTypes.Field:
AssertAreSameField((FieldInfo)member, (FieldInfoSlim)slimMember);
return;
case MemberTypes.Method:
AssertAreSameMethod((MethodInfo)member, (MethodInfoSlim)slimMember);
return;
case MemberTypes.Property:
AssertAreSameProperty((PropertyInfo)member, (PropertyInfoSlim)slimMember);
return;
}
Fail(member, slimMember);
}
private static void Fail(MemberInfo member, MemberInfoSlim slimMember)
{
Assert.Fail(string.Format(CultureInfo.InvariantCulture, "Expected '{0}', Actual: '{1}'", member, slimMember));
}
internal MemberMemberBindingSlim(MemberInfoSlim member, ReadOnlyCollection<MemberBindingSlim> bindings)
: base(member)
{
Bindings = bindings;
}
internal MemberAssignmentSlim(MemberInfoSlim member, ExpressionSlim expression)
: base(member)
{
Expression = expression;
}
protected override bool EqualsExtension(MemberInfoSlim x, MemberInfoSlim y) => true;
protected override bool EqualsNestedType(MemberInfoSlim x, MemberInfoSlim y) => true;
internal MemberListBindingSlim(MemberInfoSlim member, ReadOnlyCollection <ElementInitSlim> initializers)
: base(member)
{
Initializers = initializers;
}
protected override bool EqualsTypeInfo(MemberInfoSlim x, MemberInfoSlim y) => true;
internal MemberBindingSlim(MemberInfoSlim member)
{
Member = member;
}
private void Append(MemberInfoSlim member) => _sb.Append(member?.ToString());
protected override bool EqualsEvent(MemberInfoSlim x, MemberInfoSlim y) => true;
protected override int GetHashCodeCustom(MemberInfoSlim obj) => 42;
protected override int GetHashCodeTypeInfo(MemberInfoSlim obj) => 42;
protected override int GetHashCodeNestedType(MemberInfoSlim obj) => 42;
protected override int GetHashCodeExtension(MemberInfoSlim obj) => 42;
protected override int GetHashCodeEvent(MemberInfoSlim obj) => 42;
internal InstanceMemberExpressionSlim(ExpressionSlim expression, MemberInfoSlim member)
: base(member)
{
Expression = expression;
}
internal MemberExpressionSlim(MemberInfoSlim member)
{
Member = member;
}
// NB: Hashing of members is independent of any context. This assumption would change in case members
// could have references to generic parameters of defining types. However, we don't deal with open
// generic declaring types for members in the context of expression trees, so we can memoize just
// fine over here.
public override int Visit(MemberInfoSlim member) => _visitCache.Delegate(member);
protected override bool EqualsCustom(MemberInfoSlim x, MemberInfoSlim y) => true;
