|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic.Utils;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using AstUtils = System.Linq.Expressions.Utils;
namespace System.Dynamic
{
/// <summary>
/// Represents a set of binding restrictions on the <see cref="DynamicMetaObject"/> under which the dynamic binding is valid.
/// </summary>
[DebuggerTypeProxy(typeof(BindingRestrictionsProxy)), DebuggerDisplay("{DebugView}")]
public abstract class BindingRestrictions
{
/// <summary>
/// Represents an empty set of binding restrictions. This field is read-only.
/// </summary>
public static readonly BindingRestrictions Empty = new CustomRestriction(AstUtils.Constant(true));
private const int TypeRestrictionHash = 0b_0100_1001_0010_0100_1001_0010_0100_1001;
private const int InstanceRestrictionHash = unchecked((int)0b_1001_0010_0100_1001_0010_0100_1001_0010);
private const int CustomRestrictionHash = 0b_0010_0100_1001_0010_0100_1001_0010_0100;
private BindingRestrictions()
{
}
// Overridden by specialized subclasses
internal abstract Expression GetExpression();
/// <summary>
/// Merges the set of binding restrictions with the current binding restrictions.
/// </summary>
/// <param name="restrictions">The set of restrictions with which to merge the current binding restrictions.</param>
/// <returns>The new set of binding restrictions.</returns>
public BindingRestrictions Merge(BindingRestrictions restrictions)
{
ArgumentNullException.ThrowIfNull(restrictions);
if (this == Empty)
{
return restrictions;
}
if (restrictions == Empty)
{
return this;
}
return new MergedRestriction(this, restrictions);
}
/// <summary>
/// Creates the binding restriction that check the expression for runtime type identity.
/// </summary>
/// <param name="expression">The expression to test.</param>
/// <param name="type">The exact type to test.</param>
/// <returns>The new binding restrictions.</returns>
public static BindingRestrictions GetTypeRestriction(Expression expression, Type type)
{
ArgumentNullException.ThrowIfNull(expression);
ArgumentNullException.ThrowIfNull(type);
return new TypeRestriction(expression, type);
}
/// <summary>
/// The method takes a DynamicMetaObject, and returns an instance restriction for testing null if the object
/// holds a null value, otherwise returns a type restriction.
/// </summary>
internal static BindingRestrictions GetTypeRestriction(DynamicMetaObject obj)
{
Debug.Assert(obj != null);
if (obj.Value == null && obj.HasValue)
{
return GetInstanceRestriction(obj.Expression, null);
}
else
{
return GetTypeRestriction(obj.Expression, obj.LimitType);
}
}
/// <summary>
/// Creates the binding restriction that checks the expression for object instance identity.
/// </summary>
/// <param name="expression">The expression to test.</param>
/// <param name="instance">The exact object instance to test.</param>
/// <returns>The new binding restrictions.</returns>
public static BindingRestrictions GetInstanceRestriction(Expression expression, object? instance)
{
ArgumentNullException.ThrowIfNull(expression);
return new InstanceRestriction(expression, instance);
}
/// <summary>
/// Creates the binding restriction that checks the expression for arbitrary immutable properties.
/// </summary>
/// <param name="expression">The expression expressing the restrictions.</param>
/// <returns>The new binding restrictions.</returns>
/// <remarks>
/// By convention, the general restrictions created by this method must only test
/// immutable object properties.
/// </remarks>
public static BindingRestrictions GetExpressionRestriction(Expression expression)
{
ArgumentNullException.ThrowIfNull(expression);
ContractUtils.Requires(expression.Type == typeof(bool), nameof(expression));
return new CustomRestriction(expression);
}
/// <summary>
/// Combines binding restrictions from the list of <see cref="DynamicMetaObject"/> instances into one set of restrictions.
/// </summary>
/// <param name="contributingObjects">The list of <see cref="DynamicMetaObject"/> instances from which to combine restrictions.</param>
/// <returns>The new set of binding restrictions.</returns>
public static BindingRestrictions Combine(IList<DynamicMetaObject>? contributingObjects)
{
BindingRestrictions res = Empty;
if (contributingObjects != null)
{
foreach (DynamicMetaObject mo in contributingObjects)
{
if (mo != null)
{
res = res.Merge(mo.Restrictions);
}
}
}
return res;
}
/// <summary>
/// Builds a balanced tree of AndAlso nodes.
/// We do this so the compiler won't stack overflow if we have many
/// restrictions.
/// </summary>
private sealed class TestBuilder
{
private readonly HashSet<BindingRestrictions> _unique = new HashSet<BindingRestrictions>();
private readonly Stack<AndNode> _tests = new Stack<AndNode>();
private struct AndNode
{
internal int Depth;
internal Expression Node;
}
internal void Append(BindingRestrictions restrictions)
{
if (_unique.Add(restrictions))
{
Push(restrictions.GetExpression(), 0);
}
}
internal Expression ToExpression()
{
Expression result = _tests.Pop().Node;
while (_tests.Count > 0)
{
result = Expression.AndAlso(_tests.Pop().Node, result);
}
return result;
}
private void Push(Expression node, int depth)
{
while (_tests.Count > 0 && _tests.Peek().Depth == depth)
{
node = Expression.AndAlso(_tests.Pop().Node, node);
depth++;
}
_tests.Push(new AndNode { Node = node, Depth = depth });
}
}
/// <summary>
/// Creates the <see cref="Expression"/> representing the binding restrictions.
/// </summary>
/// <returns>The expression tree representing the restrictions.</returns>
public Expression ToExpression() => GetExpression();
private sealed class MergedRestriction : BindingRestrictions
{
internal readonly BindingRestrictions Left;
internal readonly BindingRestrictions Right;
internal MergedRestriction(BindingRestrictions left, BindingRestrictions right)
{
Left = left;
Right = right;
}
internal override Expression GetExpression()
{
// We could optimize this better, e.g. common subexpression elimination
// But for now, it's good enough.
var testBuilder = new TestBuilder();
// Visit the tree, left to right.
// Use an explicit stack so we don't stack overflow.
//
// Left-most node is on top of the stack, so we always expand the
// left most node each iteration.
var stack = new Stack<BindingRestrictions>();
BindingRestrictions top = this;
while (true)
{
if (top is MergedRestriction m)
{
stack.Push(m.Right);
top = m.Left;
}
else
{
testBuilder.Append(top);
if (stack.Count == 0)
{
return testBuilder.ToExpression();
}
top = stack.Pop();
}
}
}
}
private sealed class CustomRestriction : BindingRestrictions
{
private readonly Expression _expression;
internal CustomRestriction(Expression expression)
{
Debug.Assert(expression != null);
_expression = expression;
}
public override bool Equals([NotNullWhen(true)] object? obj)
{
return obj is CustomRestriction other && other._expression == _expression;
}
public override int GetHashCode() => CustomRestrictionHash ^ _expression.GetHashCode();
internal override Expression GetExpression() => _expression;
}
private sealed class TypeRestriction : BindingRestrictions
{
private readonly Expression _expression;
private readonly Type _type;
internal TypeRestriction(Expression parameter, Type type)
{
Debug.Assert(parameter != null);
Debug.Assert(type != null);
_expression = parameter;
_type = type;
}
public override bool Equals([NotNullWhen(true)] object? obj)
{
return obj is TypeRestriction other && other._expression == _expression && TypeUtils.AreEquivalent(other._type, _type);
}
public override int GetHashCode() => TypeRestrictionHash ^ _expression.GetHashCode() ^ _type.GetHashCode();
internal override Expression GetExpression() => Expression.TypeEqual(_expression, _type);
}
private sealed class InstanceRestriction : BindingRestrictions
{
private readonly Expression _expression;
private readonly object? _instance;
internal InstanceRestriction(Expression parameter, object? instance)
{
Debug.Assert(parameter != null);
_expression = parameter;
_instance = instance;
}
public override bool Equals([NotNullWhen(true)] object? obj)
{
return obj is InstanceRestriction other && other._expression == _expression && other._instance == _instance;
}
public override int GetHashCode()
=> InstanceRestrictionHash ^ RuntimeHelpers.GetHashCode(_instance!) ^ _expression.GetHashCode();
internal override Expression GetExpression()
{
if (_instance == null)
{
return Expression.Equal(
Expression.Convert(_expression, typeof(object)),
AstUtils.Null
);
}
ParameterExpression temp = Expression.Parameter(typeof(object), null);
return Expression.Block(
new TrueReadOnlyCollection<ParameterExpression>(temp),
new TrueReadOnlyCollection<Expression>(
#if ENABLEDYNAMICPROGRAMMING
Expression.Assign(
temp,
Expression.Property(
Expression.Constant(new WeakReference(_instance)),
typeof(WeakReference).GetProperty("Target")
)
),
#else
Expression.Assign(
temp,
Expression.Constant(_instance, typeof(object))
),
#endif
Expression.AndAlso(
//check that WeakReference was not collected.
Expression.NotEqual(temp, AstUtils.Null),
Expression.Equal(
Expression.Convert(_expression, typeof(object)),
temp
)
)
)
);
}
}
private string DebugView => ToExpression().ToString();
private sealed class BindingRestrictionsProxy
{
private readonly BindingRestrictions _node;
public BindingRestrictionsProxy(BindingRestrictions node)
{
ArgumentNullException.ThrowIfNull(node);
_node = node;
}
public bool IsEmpty => _node == Empty;
public Expression Test => _node.ToExpression();
public BindingRestrictions[] Restrictions
{
get
{
var restrictions = new List<BindingRestrictions>();
// Visit the tree, left to right
//
// Left-most node is on top of the stack, so we always expand the
// left most node each iteration.
var stack = new Stack<BindingRestrictions>();
BindingRestrictions top = _node;
while (true)
{
if (top is MergedRestriction m)
{
stack.Push(m.Right);
top = m.Left;
}
else
{
restrictions.Add(top);
if (stack.Count == 0)
{
return restrictions.ToArray();
}
top = stack.Pop();
}
}
}
}
// To prevent fxcop warning about this field
public override string ToString() => _node.DebugView;
}
}
}
|