BlockExpressionList.cs

Go to the documentation of this file.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic.Utils;
 
namespace System.Linq.Expressions;
 
internal sealed class BlockExpressionList : IList<Expression>, ICollection<Expression>, IEnumerable<Expression>, IEnumerable
{
    private readonly BlockExpression _block;
 
    private readonly Expression _arg0;
 
    public Expression this[int index]
    {
        get
        {
            if (index == 0)
            {
                return _arg0;
            }
            return _block.GetExpression(index);
        }
        [ExcludeFromCodeCoverage(Justification = "Unreachable")]
        set
        {
            throw ContractUtils.Unreachable;
        }
    }
    public Expression this[int index] {…};
 
    public int Count => _block.ExpressionCount;
 
    [ExcludeFromCodeCoverage(Justification = "Unreachable")]
    public bool IsReadOnly
    {
        get
        {
            throw ContractUtils.Unreachable;
        }
    }
    public bool IsReadOnly {…};
 
    internal BlockExpressionList(BlockExpression provider, Expression arg0)
    {
        _block = provider;
        _arg0 = arg0;
    }
    internal BlockExpressionList(BlockExpression provider, Expression arg0) {…}
 
    public int IndexOf(Expression item)
    {
        if (_arg0 == item)
        {
            return 0;
        }
        for (int i = 1; i < _block.ExpressionCount; i++)
        {
            if (_block.GetExpression(i) == item)
            {
                return i;
            }
        }
        return -1;
    }
    public int IndexOf(Expression item) {…}
 
    [ExcludeFromCodeCoverage(Justification = "Unreachable")]
    public void Insert(int index, Expression item)
    {
        throw ContractUtils.Unreachable;
    }
    public void Insert(int index, Expression item) {…}
 
    [ExcludeFromCodeCoverage(Justification = "Unreachable")]
    public void RemoveAt(int index)
    {
        throw ContractUtils.Unreachable;
    }
    public void RemoveAt(int index) {…}
 
    [ExcludeFromCodeCoverage(Justification = "Unreachable")]
    public void Add(Expression item)
    {
        throw ContractUtils.Unreachable;
    }
    public void Add(Expression item) {…}
 
    [ExcludeFromCodeCoverage(Justification = "Unreachable")]
    public void Clear()
    {
        throw ContractUtils.Unreachable;
    }
    public void Clear() {…}
 
    public bool Contains(Expression item)
    {
        return IndexOf(item) != -1;
    }
    public bool Contains(Expression item) {…}
 
    public void CopyTo(Expression[] array, int index)
    {
        ContractUtils.RequiresNotNull(array, "array");
        if (index < 0)
        {
            throw Error.ArgumentOutOfRange("index");
        }
        int expressionCount = _block.ExpressionCount;
        if (index + expressionCount > array.Length)
        {
            throw new ArgumentException();
        }
        array[index++] = _arg0;
        for (int i = 1; i < expressionCount; i++)
        {
            array[index++] = _block.GetExpression(i);
        }
    }
    public void CopyTo(Expression[] array, int index) {…}
 
    [ExcludeFromCodeCoverage(Justification = "Unreachable")]
    public bool Remove(Expression item)
    {
        throw ContractUtils.Unreachable;
    }
    public bool Remove(Expression item) {…}
 
    public IEnumerator<Expression> GetEnumerator()
    {
        yield return _arg0;
        for (int i = 1; i < _block.ExpressionCount; i++)
        {
            yield return _block.GetExpression(i);
        }
    }
    public IEnumerator<Expression> GetEnumerator() {…}
 
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator() {…}
}
internal sealed class BlockExpressionList : IList<Expression>, ICollection<Expression>, IEnumerable<Expression>, IEnumerable {…};