File: Microsoft\CSharp\RuntimeBinder\Semantics\Tree\Visitors\ExprVisitorBase.cs
Web Access
Project: src\src\libraries\Microsoft.CSharp\src\Microsoft.CSharp.csproj (Microsoft.CSharp)
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
 
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
 
namespace Microsoft.CSharp.RuntimeBinder.Semantics
{
    internal abstract class ExprVisitorBase
    {
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected Expr Visit(Expr pExpr) => pExpr == null ? null : Dispatch(pExpr);
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr Dispatch(Expr pExpr) =>
            pExpr.Kind switch
            {
                ExpressionKind.BinaryOp => VisitBINOP(pExpr as ExprBinOp),
                ExpressionKind.UnaryOp => VisitUNARYOP(pExpr as ExprUnaryOp),
                ExpressionKind.Assignment => VisitASSIGNMENT(pExpr as ExprAssignment),
                ExpressionKind.List => VisitLIST(pExpr as ExprList),
                ExpressionKind.ArrayIndex => VisitARRAYINDEX(pExpr as ExprArrayIndex),
                ExpressionKind.Call => VisitCALL(pExpr as ExprCall),
                ExpressionKind.Field => VisitFIELD(pExpr as ExprField),
                ExpressionKind.Local => VisitLOCAL(pExpr as ExprLocal),
                ExpressionKind.Constant => VisitCONSTANT(pExpr as ExprConstant),
                ExpressionKind.Class => pExpr,
                ExpressionKind.Property => VisitPROP(pExpr as ExprProperty),
                ExpressionKind.Multi => VisitMULTI(pExpr as ExprMulti),
                ExpressionKind.MultiGet => VisitMULTIGET(pExpr as ExprMultiGet),
                ExpressionKind.Wrap => VisitWRAP(pExpr as ExprWrap),
                ExpressionKind.Concat => VisitCONCAT(pExpr as ExprConcat),
                ExpressionKind.ArrayInit => VisitARRINIT(pExpr as ExprArrayInit),
                ExpressionKind.Cast => VisitCAST(pExpr as ExprCast),
                ExpressionKind.UserDefinedConversion => VisitUSERDEFINEDCONVERSION(pExpr as ExprUserDefinedConversion),
                ExpressionKind.TypeOf => VisitTYPEOF(pExpr as ExprTypeOf),
                ExpressionKind.ZeroInit => VisitZEROINIT(pExpr as ExprZeroInit),
                ExpressionKind.UserLogicalOp => VisitUSERLOGOP(pExpr as ExprUserLogicalOp),
                ExpressionKind.MemberGroup => VisitMEMGRP(pExpr as ExprMemberGroup),
                ExpressionKind.FieldInfo => VisitFIELDINFO(pExpr as ExprFieldInfo),
                ExpressionKind.MethodInfo => VisitMETHODINFO(pExpr as ExprMethodInfo),
 
                // Binary operators
                ExpressionKind.EqualsParam => VisitEQUALS(pExpr as ExprBinOp),
                ExpressionKind.Compare => VisitCOMPARE(pExpr as ExprBinOp),
                ExpressionKind.NotEq => VisitNE(pExpr as ExprBinOp),
                ExpressionKind.LessThan => VisitLT(pExpr as ExprBinOp),
                ExpressionKind.LessThanOrEqual => VisitLE(pExpr as ExprBinOp),
                ExpressionKind.GreaterThan => VisitGT(pExpr as ExprBinOp),
                ExpressionKind.GreaterThanOrEqual => VisitGE(pExpr as ExprBinOp),
                ExpressionKind.Add => VisitADD(pExpr as ExprBinOp),
                ExpressionKind.Subtract => VisitSUB(pExpr as ExprBinOp),
                ExpressionKind.Multiply => VisitMUL(pExpr as ExprBinOp),
                ExpressionKind.Divide => VisitDIV(pExpr as ExprBinOp),
                ExpressionKind.Modulo => VisitMOD(pExpr as ExprBinOp),
                ExpressionKind.BitwiseAnd => VisitBITAND(pExpr as ExprBinOp),
                ExpressionKind.BitwiseOr => VisitBITOR(pExpr as ExprBinOp),
                ExpressionKind.BitwiseExclusiveOr => VisitBITXOR(pExpr as ExprBinOp),
                ExpressionKind.LeftShirt => VisitLSHIFT(pExpr as ExprBinOp),
                ExpressionKind.RightShift => VisitRSHIFT(pExpr as ExprBinOp),
                ExpressionKind.LogicalAnd => VisitLOGAND(pExpr as ExprBinOp),
                ExpressionKind.LogicalOr => VisitLOGOR(pExpr as ExprBinOp),
                ExpressionKind.Sequence => VisitSEQUENCE(pExpr as ExprBinOp),
                ExpressionKind.Save => VisitSAVE(pExpr as ExprBinOp),
                ExpressionKind.Swap => VisitSWAP(pExpr as ExprBinOp),
                ExpressionKind.Indir => VisitINDIR(pExpr as ExprBinOp),
                ExpressionKind.StringEq => VisitSTRINGEQ(pExpr as ExprBinOp),
                ExpressionKind.StringNotEq => VisitSTRINGNE(pExpr as ExprBinOp),
                ExpressionKind.DelegateEq => VisitDELEGATEEQ(pExpr as ExprBinOp),
                ExpressionKind.DelegateNotEq => VisitDELEGATENE(pExpr as ExprBinOp),
                ExpressionKind.DelegateAdd => VisitDELEGATEADD(pExpr as ExprBinOp),
                ExpressionKind.DelegateSubtract => VisitDELEGATESUB(pExpr as ExprBinOp),
                ExpressionKind.Eq => VisitEQ(pExpr as ExprBinOp),
 
                // Unary operators
                ExpressionKind.True => VisitTRUE(pExpr as ExprUnaryOp),
                ExpressionKind.False => VisitFALSE(pExpr as ExprUnaryOp),
                ExpressionKind.Inc => VisitINC(pExpr as ExprUnaryOp),
                ExpressionKind.Dec => VisitDEC(pExpr as ExprUnaryOp),
                ExpressionKind.LogicalNot => VisitLOGNOT(pExpr as ExprUnaryOp),
                ExpressionKind.Negate => VisitNEG(pExpr as ExprUnaryOp),
                ExpressionKind.UnaryPlus => VisitUPLUS(pExpr as ExprUnaryOp),
                ExpressionKind.BitwiseNot => VisitBITNOT(pExpr as ExprUnaryOp),
                ExpressionKind.Addr => VisitADDR(pExpr as ExprUnaryOp),
                ExpressionKind.DecimalNegate => VisitDECIMALNEG(pExpr as ExprUnaryOp),
                ExpressionKind.DecimalInc => VisitDECIMALINC(pExpr as ExprUnaryOp),
                ExpressionKind.DecimalDec => VisitDECIMALDEC(pExpr as ExprUnaryOp),
                _ => throw Error.InternalCompilerError(),
            };
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        private void VisitChildren(Expr pExpr)
        {
            Debug.Assert(pExpr != null);
 
            Expr exprRet;
 
            switch (pExpr.Kind)
            {
                case ExpressionKind.List:
 
                    // Lists are a special case.  We treat a list not as a
                    // binary node but rather as a node with n children.
                    ExprList list = (ExprList)pExpr;
                    while (true)
                    {
                        list.OptionalElement = Visit(list.OptionalElement);
                        Expr nextNode = list.OptionalNextListNode;
                        if (nextNode == null)
                        {
                            return;
                        }
 
                        if (!(nextNode is ExprList next))
                        {
                            list.OptionalNextListNode = Visit(nextNode);
                            return;
                        }
 
                        list = next;
                    }
 
                case ExpressionKind.Assignment:
                    exprRet = Visit((pExpr as ExprAssignment).LHS);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprAssignment).LHS = exprRet;
                    exprRet = Visit((pExpr as ExprAssignment).RHS);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprAssignment).RHS = exprRet;
                    break;
 
                case ExpressionKind.ArrayIndex:
                    exprRet = Visit((pExpr as ExprArrayIndex).Array);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprArrayIndex).Array = exprRet;
                    exprRet = Visit((pExpr as ExprArrayIndex).Index);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprArrayIndex).Index = exprRet;
                    break;
 
                case ExpressionKind.UnaryOp:
                case ExpressionKind.True:
                case ExpressionKind.False:
                case ExpressionKind.Inc:
                case ExpressionKind.Dec:
                case ExpressionKind.LogicalNot:
                case ExpressionKind.Negate:
                case ExpressionKind.UnaryPlus:
                case ExpressionKind.BitwiseNot:
                case ExpressionKind.Addr:
                case ExpressionKind.DecimalNegate:
                case ExpressionKind.DecimalInc:
                case ExpressionKind.DecimalDec:
                    exprRet = Visit((pExpr as ExprUnaryOp).Child);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprUnaryOp).Child = exprRet;
                    break;
 
                case ExpressionKind.UserLogicalOp:
                    exprRet = Visit((pExpr as ExprUserLogicalOp).TrueFalseCall);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprUserLogicalOp).TrueFalseCall = exprRet;
                    exprRet = Visit((pExpr as ExprUserLogicalOp).OperatorCall);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprUserLogicalOp).OperatorCall = exprRet as ExprCall;
                    exprRet = Visit((pExpr as ExprUserLogicalOp).FirstOperandToExamine);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprUserLogicalOp).FirstOperandToExamine = exprRet;
                    break;
 
                case ExpressionKind.TypeOf:
                    break;
 
                case ExpressionKind.Cast:
                    exprRet = Visit((pExpr as ExprCast).Argument);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprCast).Argument = exprRet;
                    break;
 
                case ExpressionKind.UserDefinedConversion:
                    exprRet = Visit((pExpr as ExprUserDefinedConversion).UserDefinedCall);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprUserDefinedConversion).UserDefinedCall = exprRet;
                    break;
 
                case ExpressionKind.ZeroInit:
                    break;
 
                case ExpressionKind.MemberGroup:
 
                    // The object expression. NULL for a static invocation.
                    exprRet = Visit((pExpr as ExprMemberGroup).OptionalObject);
                    (pExpr as ExprMemberGroup).OptionalObject = exprRet;
                    break;
 
                case ExpressionKind.Call:
                    exprRet = Visit((pExpr as ExprCall).OptionalArguments);
                    (pExpr as ExprCall).OptionalArguments = exprRet;
                    exprRet = Visit((pExpr as ExprCall).MemberGroup);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprCall).MemberGroup = exprRet as ExprMemberGroup;
                    break;
 
                case ExpressionKind.Property:
                    exprRet = Visit((pExpr as ExprProperty).OptionalArguments);
                    (pExpr as ExprProperty).OptionalArguments = exprRet;
                    exprRet = Visit((pExpr as ExprProperty).MemberGroup);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprProperty).MemberGroup = exprRet as ExprMemberGroup;
                    break;
 
                case ExpressionKind.Field:
                    exprRet = Visit((pExpr as ExprField).OptionalObject);
                    (pExpr as ExprField).OptionalObject = exprRet;
                    break;
 
                case ExpressionKind.Constant:
 
                    // Used for when we zeroinit 0 parameter constructors for structs/enums.
                    exprRet = Visit((pExpr as ExprConstant).OptionalConstructorCall);
                    (pExpr as ExprConstant).OptionalConstructorCall = exprRet;
                    break;
 
                /*************************************************************************************************
                  TYPEEXPRs defined:
 
                  The following exprs are used to represent the results of type binding, and are defined as follows:
 
                  TYPEARGUMENTS - This wraps the type arguments for a class. It contains the TypeArray* which is
                    associated with the AggregateType for the instantiation of the class.
 
                  TYPEORNAMESPACE - This is the base class for this set of Exprs. When binding a type, the result
                    must be a type or a namespace. This Expr encapsulates that fact. The lhs member is the Expr
                    tree that was bound to resolve the type or namespace.
 
                  TYPEORNAMESPACEERROR - This is the error class for the type or namespace exprs when we don't know
                    what to bind it to.
 
                  The following two exprs all have a TYPEORNAMESPACE child, which is their fundamental type:
                    POINTERTYPE - This wraps the sym for the pointer type.
                    NULLABLETYPE - This wraps the sym for the nullable type.
 
                  CLASS - This represents an instantiation of a class.
 
                  NSPACE - This represents a namespace, which is the intermediate step when attempting to bind
                    a qualified name.
 
                  ALIAS - This represents an alias
 
                *************************************************************************************************/
 
                case ExpressionKind.Multi:
                    exprRet = Visit((pExpr as ExprMulti).Left);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprMulti).Left = exprRet;
                    exprRet = Visit((pExpr as ExprMulti).Operator);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprMulti).Operator = exprRet;
                    break;
 
                case ExpressionKind.Concat:
                    exprRet = Visit((pExpr as ExprConcat).FirstArgument);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprConcat).FirstArgument = exprRet;
                    exprRet = Visit((pExpr as ExprConcat).SecondArgument);
                    Debug.Assert(exprRet != null);
                    (pExpr as ExprConcat).SecondArgument = exprRet;
                    break;
 
                case ExpressionKind.ArrayInit:
                    exprRet = Visit((pExpr as ExprArrayInit).OptionalArguments);
                    (pExpr as ExprArrayInit).OptionalArguments = exprRet;
                    exprRet = Visit((pExpr as ExprArrayInit).OptionalArgumentDimensions);
                    (pExpr as ExprArrayInit).OptionalArgumentDimensions = exprRet;
                    break;
 
                case ExpressionKind.Local:
                case ExpressionKind.Class:
                case ExpressionKind.MultiGet:
                case ExpressionKind.Wrap:
                case ExpressionKind.NoOp:
                case ExpressionKind.FieldInfo:
                case ExpressionKind.MethodInfo:
                    break;
 
                default:
                    pExpr.AssertIsBin();
                    exprRet = Visit((pExpr as ExprBinOp).OptionalLeftChild);
                    (pExpr as ExprBinOp).OptionalLeftChild = exprRet;
                    exprRet = Visit((pExpr as ExprBinOp).OptionalRightChild);
                    (pExpr as ExprBinOp).OptionalRightChild = exprRet;
                    break;
            }
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitEXPR(Expr pExpr)
        {
            VisitChildren(pExpr);
            return pExpr;
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitBINOP(ExprBinOp pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLIST(ExprList pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitASSIGNMENT(ExprAssignment pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitARRAYINDEX(ExprArrayIndex pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitUNARYOP(ExprUnaryOp pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitUSERLOGOP(ExprUserLogicalOp pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitTYPEOF(ExprTypeOf pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitCAST(ExprCast pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitUSERDEFINEDCONVERSION(ExprUserDefinedConversion pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitZEROINIT(ExprZeroInit pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitMEMGRP(ExprMemberGroup pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitCALL(ExprCall pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitPROP(ExprProperty pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitFIELD(ExprField pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLOCAL(ExprLocal pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitCONSTANT(ExprConstant pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitMULTIGET(ExprMultiGet pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitMULTI(ExprMulti pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitWRAP(ExprWrap pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitCONCAT(ExprConcat pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitARRINIT(ExprArrayInit pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitFIELDINFO(ExprFieldInfo pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitMETHODINFO(ExprMethodInfo pExpr)
        {
            return VisitEXPR(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitEQUALS(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitCOMPARE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitEQ(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitNE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitGE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitADD(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitSUB(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDIV(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitBITAND(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitBITOR(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLSHIFT(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLOGAND(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitSEQUENCE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitSAVE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitINDIR(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitSTRINGEQ(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDELEGATEEQ(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDELEGATEADD(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLT(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitMUL(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitBITXOR(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitRSHIFT(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLOGOR(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitSTRINGNE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDELEGATENE(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitGT(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitMOD(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitSWAP(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDELEGATESUB(ExprBinOp pExpr)
        {
            return VisitBINOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitTRUE(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitINC(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitLOGNOT(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitNEG(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitBITNOT(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitADDR(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDECIMALNEG(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDECIMALDEC(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitFALSE(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDEC(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitUPLUS(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
 
        [RequiresUnreferencedCode(Binder.TrimmerWarning)]
        protected virtual Expr VisitDECIMALINC(ExprUnaryOp pExpr)
        {
            return VisitUNARYOP(pExpr);
        }
    }
}