57Debug.Assert(binOp.Kind == ExpressionKind.Sequence);

987?? _binder.bindUDUnop(op == OperatorKind.OP_TRUE ? ExpressionKind.True : ExpressionKind.False, arg1) 1012ExpressionKind ek = Operators.GetExpressionKind(GetOperatorKind(payload.Operation, payload.IsLogicalOperation)); 1019if (ek > ExpressionKind.MultiOffset) 1021ek = (ExpressionKind)(ek - ExpressionKind.MultiOffset);

15public readonly ExpressionKind ExpressionKind; 17public OperatorInfo(TokenKind kind, PredefinedName pn, ExpressionKind e) 26new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 27new OperatorInfo(TokenKind.Equal, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 28new OperatorInfo(TokenKind.PlusEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.Add ), 29new OperatorInfo(TokenKind.MinusEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.Subtract ), 30new OperatorInfo(TokenKind.SplatEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.Multiply ), 31new OperatorInfo(TokenKind.SlashEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.Divide ), 32new OperatorInfo(TokenKind.PercentEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.Modulo ), 33new OperatorInfo(TokenKind.AndEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.BitwiseAnd ), 34new OperatorInfo(TokenKind.HatEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.BitwiseExclusiveOr), 35new OperatorInfo(TokenKind.BarEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.BitwiseOr ), 36new OperatorInfo(TokenKind.LeftShiftEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.LeftShirt ), 37new OperatorInfo(TokenKind.RightShiftEqual, PredefinedName.PN_COUNT, ExpressionKind.MultiOffset + (int)ExpressionKind.RightShift ), 38new OperatorInfo(TokenKind.Question, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 39new OperatorInfo(TokenKind.QuestionQuestion, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 40new OperatorInfo(TokenKind.LogicalOr, PredefinedName.PN_COUNT, ExpressionKind.LogicalOr ), 41new OperatorInfo(TokenKind.LogicalAnd, PredefinedName.PN_COUNT, ExpressionKind.LogicalAnd ), 42new OperatorInfo(TokenKind.Bar, PredefinedName.PN_OPBITWISEOR, ExpressionKind.BitwiseOr ), 43new OperatorInfo(TokenKind.Hat, PredefinedName.PN_OPXOR, ExpressionKind.BitwiseExclusiveOr ), 44new OperatorInfo(TokenKind.Ampersand, PredefinedName.PN_OPBITWISEAND, ExpressionKind.BitwiseAnd ), 45new OperatorInfo(TokenKind.EqualEqual, PredefinedName.PN_OPEQUALITY, ExpressionKind.Eq ), 46new OperatorInfo(TokenKind.NotEqual, PredefinedName.PN_OPINEQUALITY, ExpressionKind.NotEq ), 47new OperatorInfo(TokenKind.LessThan, PredefinedName.PN_OPLESSTHAN, ExpressionKind.LessThan ), 48new OperatorInfo(TokenKind.LessThanEqual, PredefinedName.PN_OPLESSTHANOREQUAL, ExpressionKind.LessThanOrEqual ), 49new OperatorInfo(TokenKind.GreaterThan, PredefinedName.PN_OPGREATERTHAN, ExpressionKind.GreaterThan ), 50new OperatorInfo(TokenKind.GreaterThanEqual, PredefinedName.PN_OPGREATERTHANOREQUAL, ExpressionKind.GreaterThanOrEqual ), 51new OperatorInfo(TokenKind.Is, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 52new OperatorInfo(TokenKind.As, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 53new OperatorInfo(TokenKind.LeftShift, PredefinedName.PN_OPLEFTSHIFT, ExpressionKind.LeftShirt ), 54new OperatorInfo(TokenKind.RightShift, PredefinedName.PN_OPRIGHTSHIFT, ExpressionKind.RightShift ), 55new OperatorInfo(TokenKind.Plus, PredefinedName.PN_OPPLUS, ExpressionKind.Add ), 56new OperatorInfo(TokenKind.Minus, PredefinedName.PN_OPMINUS, ExpressionKind.Subtract ), 57new OperatorInfo(TokenKind.Splat, PredefinedName.PN_OPMULTIPLY, ExpressionKind.Multiply ), 58new OperatorInfo(TokenKind.Slash, PredefinedName.PN_OPDIVISION, ExpressionKind.Divide ), 59new OperatorInfo(TokenKind.Percent, PredefinedName.PN_OPMODULUS, ExpressionKind.Modulo ), 60new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 61new OperatorInfo(TokenKind.Plus, PredefinedName.PN_OPUNARYPLUS, ExpressionKind.UnaryPlus ), 62new OperatorInfo(TokenKind.Minus, PredefinedName.PN_OPUNARYMINUS, ExpressionKind.Negate ), 63new OperatorInfo(TokenKind.Tilde, PredefinedName.PN_OPCOMPLEMENT, ExpressionKind.BitwiseNot ), 64new OperatorInfo(TokenKind.Bang, PredefinedName.PN_OPNEGATION, ExpressionKind.LogicalNot ), 65new OperatorInfo(TokenKind.PlusPlus, PredefinedName.PN_OPINCREMENT, ExpressionKind.Add ), 66new OperatorInfo(TokenKind.MinusMinus, PredefinedName.PN_OPDECREMENT, ExpressionKind.Subtract ), 67new OperatorInfo(TokenKind.TypeOf, PredefinedName.PN_COUNT, ExpressionKind.TypeOf ), 68new OperatorInfo(TokenKind.Checked, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 69new OperatorInfo(TokenKind.Unchecked, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 70new OperatorInfo(TokenKind.MakeRef, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 71new OperatorInfo(TokenKind.RefValue, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 72new OperatorInfo(TokenKind.RefType, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 73new OperatorInfo(TokenKind.ArgList, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 74new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 75new OperatorInfo(TokenKind.Splat, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 76new OperatorInfo(TokenKind.Ampersand, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 77new OperatorInfo(TokenKind.Colon, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 78new OperatorInfo(TokenKind.This, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 79new OperatorInfo(TokenKind.Base, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 80new OperatorInfo(TokenKind.Null, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 81new OperatorInfo(TokenKind.True, PredefinedName.PN_OPTRUE, ExpressionKind.ExpressionKindCount ), 82new OperatorInfo(TokenKind.False, PredefinedName.PN_OPFALSE, ExpressionKind.ExpressionKindCount ), 83new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 84new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 85new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 86new OperatorInfo(TokenKind.PlusPlus, PredefinedName.PN_COUNT, ExpressionKind.Add ), 87new OperatorInfo(TokenKind.MinusMinus, PredefinedName.PN_COUNT, ExpressionKind.Subtract ), 88new OperatorInfo(TokenKind.Dot, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ), 89new OperatorInfo(TokenKind.Implicit, PredefinedName.PN_OPIMPLICITMN, ExpressionKind.ExpressionKindCount ), 90new OperatorInfo(TokenKind.Explicit, PredefinedName.PN_OPEXPLICITMN, ExpressionKind.ExpressionKindCount ), 91new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_OPEQUALS, ExpressionKind.ExpressionKindCount ), 92new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_OPCOMPARE, ExpressionKind.ExpressionKindCount ), 93new OperatorInfo(TokenKind.Unknown, PredefinedName.PN_COUNT, ExpressionKind.ExpressionKindCount ) 126public static ExpressionKind GetExpressionKind(OperatorKind op) => GetInfo(op).ExpressionKind;

262private delegate Expr PfnBindBinOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr op1, Expr op2); 263private delegate Expr PfnBindUnaOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr op); 549internal Expr bindUDUnop(ExpressionKind ek, Expr arg) 890case ExpressionKind.Property: 918case ExpressionKind.Field: 1075(((pObject.Flags & EXPRFLAG.EXF_LVALUE) != 0) && (pObject.Kind != ExpressionKind.Property)) || 1633private static Name ExpressionKindName(ExpressionKind ek) 1635Debug.Assert(ek >= ExpressionKind.FirstOp && (ek - ExpressionKind.FirstOp) < (int)EK2NAME.Length); 1636return NameManager.GetPredefinedName(EK2NAME[ek - ExpressionKind.FirstOp]);

104public static bool IsRelational(this ExpressionKind kind) 106return ExpressionKind.RelationalMin <= kind && kind <= ExpressionKind.RelationalMax; 109public static bool IsUnaryOperator(this ExpressionKind kind) 113case ExpressionKind.True: 114case ExpressionKind.False: 115case ExpressionKind.Inc: 116case ExpressionKind.Dec: 117case ExpressionKind.LogicalNot: 118case ExpressionKind.Negate: 119case ExpressionKind.UnaryPlus: 120case ExpressionKind.BitwiseNot: 121case ExpressionKind.Addr: 122case ExpressionKind.DecimalNegate: 123case ExpressionKind.DecimalInc: 124case ExpressionKind.DecimalDec:

52Debug.Assert(expr?.Kind >= ExpressionKind.TypeLimit && 0 != (expr.Flags & EXPRFLAG.EXF_BINOP)); 77while (exprVal.Kind == ExpressionKind.Sequence) 95case ExpressionKind.Constant: 96case ExpressionKind.ZeroInit:

171public static ExprBinOp CreateBinop(ExpressionKind exprKind, CType type, Expr left, Expr right) => 174public static ExprUnaryOp CreateUnaryOp(ExpressionKind exprKind, CType type, Expr operand) => 177public static ExprOperator CreateOperator(ExpressionKind exprKind, CType type, Expr arg1, Expr arg2) 186public static ExprBinOp CreateUserDefinedBinop(ExpressionKind exprKind, CType type, Expr left, Expr right, Expr call, MethPropWithInst userMethod) => 190public static ExprUnaryOp CreateUserDefinedUnaryOperator(ExpressionKind exprKind, CType type, Expr operand, ExprCall call, MethPropWithInst userMethod) => 196ExprUnaryOp unary = CreateUnaryOp(ExpressionKind.Negate, operand.Type, operand); 205CreateBinop(ExpressionKind.Sequence, second.Type, first, second); 222ExprBinOp expr = CreateBinop(ExpressionKind.Save, wrap.Type, wrap.OptionalExpression, wrap); 243if (first.Kind != ExpressionKind.List) 251Debug.Assert((last as ExprList).OptionalNextListNode.Kind != ExpressionKind.List);

147private ExprBinOp BindUserDefinedBinOp(ExpressionKind ek, BinOpArgInfo info) 160ek - ExpressionKind.LogicalAnd + ExpressionKind.BitwiseAnd, info.arg1, info.arg2, true, out pmpwi); 465private static ExprBinOp BindNullEqualityComparison(ExpressionKind ek, BinOpArgInfo info) 500public Expr BindStandardBinop(ExpressionKind ek, Expr arg1, Expr arg2) 576private Expr BindStandardBinopCore(BinOpArgInfo info, BinOpFullSig bofs, ExpressionKind ek, EXPRFLAG flags) 619private ExprBinOp BindLiftedStandardBinOp(BinOpArgInfo info, BinOpFullSig bofs, ExpressionKind ek, EXPRFLAG flags) 918private static bool IsEnumArithmeticBinOp(ExpressionKind ek, BinOpArgInfo info) => 921ExpressionKind.Add => info.typeRaw1.IsEnumType ^ info.typeRaw2.IsEnumType, 922ExpressionKind.Subtract => info.typeRaw1.IsEnumType | info.typeRaw2.IsEnumType, 1100private static (ExpressionKind, UnaOpKind, EXPRFLAG) CalculateExprAndUnaryOpKinds(OperatorKind op, bool bChecked) 1102ExpressionKind ek; 1109ek = ExpressionKind.UnaryPlus; 1118ek = ExpressionKind.Negate; 1123ek = ExpressionKind.BitwiseNot; 1128ek = ExpressionKind.LogicalNot; 1138ek = ExpressionKind.Add; 1147ek = ExpressionKind.Add; 1157ek = ExpressionKind.Subtract; 1166ek = ExpressionKind.Subtract; 1203(ExpressionKind ek, UnaOpKind unaryOpKind, EXPRFLAG flags) = 1322private UnaryOperatorSignatureFindResult PopulateSignatureList(Expr pArgument, UnaOpKind unaryOpKind, UnaOpMask unaryOpMask, ExpressionKind exprKind, EXPRFLAG flags, List<UnaOpFullSig> pSignatures, out Expr ppResult) 1376Expr exprVal = bindUDUnop((ExpressionKind)(exprKind - ExpressionKind.Add + ExpressionKind.Inc), exprGet); 1541private ExprOperator BindLiftedStandardUnop(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1595private static ExprOperator BindIntBinOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1606private static ExprOperator BindIntUnaOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg) 1617private static ExprOperator BindRealBinOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG _, Expr arg1, Expr arg2) 1628private static ExprOperator BindRealUnaOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG _, Expr arg) 1640private Expr BindIncOp(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1642Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1665private Expr BindIncOpCore(ExpressionKind ek, EXPRFLAG flags, Expr exprVal, CType type) 1667Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1682if (ek == ExpressionKind.Add) 1684ek = ExpressionKind.DecimalInc; 1689ek = ExpressionKind.DecimalDec; 1724private Expr LScalar(ExpressionKind ek, EXPRFLAG flags, Expr exprVal, CType type, ConstVal cv, CType typeTmp) 1739private ExprMulti BindNonliftedIncOp(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1741Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1767private ExprMulti BindLiftedIncOp(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1769Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1785ExprUnaryOp exprRes = ExprFactory.CreateUnaryOp((ek == ExpressionKind.Add) ? ExpressionKind.Inc : ExpressionKind.Dec, arg.Type/* type */, exprVal); 1802private static ExprBinOp BindDecBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1817case ExpressionKind.Add: 1818case ExpressionKind.Subtract: 1819case ExpressionKind.Multiply: 1820case ExpressionKind.Divide: 1821case ExpressionKind.Modulo: 1824case ExpressionKind.LessThan: 1825case ExpressionKind.LessThanOrEqual: 1826case ExpressionKind.GreaterThan: 1827case ExpressionKind.GreaterThanOrEqual: 1828case ExpressionKind.Eq: 1829case ExpressionKind.NotEq: 1845private static ExprUnaryOp BindDecUnaOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg) 1848Debug.Assert(ek == ExpressionKind.Negate || ek == ExpressionKind.UnaryPlus); 1853if (ek == ExpressionKind.Negate) 1856return CreateUnaryOpForPredefMethodCall(ExpressionKind.DecimalNegate, predefMeth, typeDec, arg); 1858return ExprFactory.CreateUnaryOp(ExpressionKind.UnaryPlus, typeDec, arg); 1866private static Expr BindStrBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1868Debug.Assert(ek == ExpressionKind.Add); 1879private static ExprBinOp BindShiftOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1881Debug.Assert(ek == ExpressionKind.LeftShirt || ek == ExpressionKind.RightShift); 1898private static ExprBinOp BindBoolBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1910private ExprOperator BindBoolBitwiseOp(ExpressionKind ek, EXPRFLAG flags, Expr expr1, Expr expr2) 1912Debug.Assert(ek == ExpressionKind.BitwiseAnd || ek == ExpressionKind.BitwiseOr); 1947private static Expr BindLiftedBoolBitwiseOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr expr1, Expr expr2) => null; 1955private static Expr BindBoolUnaOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg) 1958Debug.Assert(ek == ExpressionKind.LogicalNot); 1969return ExprFactory.CreateUnaryOp(ExpressionKind.LogicalNot, typeBool, arg); 1981private static ExprBinOp BindStrCmpOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1983Debug.Assert(ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq); 1989PREDEFMETH predefMeth = ek == ExpressionKind.Eq ? PREDEFMETH.PM_STRING_OPEQUALITY : PREDEFMETH.PM_STRING_OPINEQUALITY; 1990ek = ek == ExpressionKind.Eq ? ExpressionKind.StringEq : ExpressionKind.StringNotEq; 2000private static ExprBinOp BindRefCmpOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 2002Debug.Assert(ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq); 2017private static Expr BindDelBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 2019Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract || ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq); 2026case ExpressionKind.Add: 2029ek = ExpressionKind.DelegateAdd; 2032case ExpressionKind.Subtract: 2035ek = ExpressionKind.DelegateSubtract; 2038case ExpressionKind.Eq: 2041ek = ExpressionKind.DelegateEq; 2044case ExpressionKind.NotEq: 2047ek = ExpressionKind.DelegateNotEq; 2059private static Expr BindEnumBinOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 2089private Expr BindLiftedEnumArithmeticBinOp(ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 2091Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 2137private static Expr BindEnumUnaOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg) 2139Debug.Assert(ek == ExpressionKind.BitwiseNot); 2161private (BinOpKind, EXPRFLAG) GetBinopKindAndFlags(ExpressionKind ek) 2167case ExpressionKind.Add: 2174case ExpressionKind.Subtract: 2181case ExpressionKind.Divide: 2182case ExpressionKind.Modulo: 2192case ExpressionKind.Multiply: 2199case ExpressionKind.BitwiseAnd: 2200case ExpressionKind.BitwiseOr: 2203case ExpressionKind.BitwiseExclusiveOr: 2206case ExpressionKind.LeftShirt: 2207case ExpressionKind.RightShift: 2210case ExpressionKind.LogicalOr: 2211case ExpressionKind.LogicalAnd: 2214case ExpressionKind.LessThan: 2215case ExpressionKind.LessThanOrEqual: 2216case ExpressionKind.GreaterThan: 2217case ExpressionKind.GreaterThanOrEqual: 2220case ExpressionKind.Eq: 2221case ExpressionKind.NotEq: 2239private ExprOperator BindIntOp(ExpressionKind kind, EXPRFLAG flags, Expr op1, Expr op2, PredefinedType ptOp) 2247Debug.Assert((op2 == null) == (kind == ExpressionKind.Negate || kind == ExpressionKind.UnaryPlus || kind == ExpressionKind.BitwiseNot)); 2249if (kind == ExpressionKind.Negate) 2326private static ExprOperator BindFloatOp(ExpressionKind kind, Expr op1, Expr op2) 2387private Expr BindUserBoolOp(ExpressionKind kind, ExprCall pCall) 2392Debug.Assert(kind == ExpressionKind.LogicalAnd || kind == ExpressionKind.LogicalOr); 2414Expr pCallT = bindUDUnop(ExpressionKind.True, pExprWrap); 2415Expr pCallF = bindUDUnop(ExpressionKind.False, pExprWrap); 2424return ExprFactory.CreateUserLogOp(typeRet, kind == ExpressionKind.LogicalAnd ? pCallF : pCallT, pCall); 2465private static bool UserDefinedBinaryOperatorCanBeLifted(ExpressionKind ek, MethodSymbol method, AggregateType ats, 2481case ExpressionKind.Eq: 2482case ExpressionKind.NotEq: 2492case ExpressionKind.GreaterThan: 2493case ExpressionKind.GreaterThanOrEqual: 2494case ExpressionKind.LessThan: 2495case ExpressionKind.LessThanOrEqual: 2511ExpressionKind ek, MethodSymbol method, AggregateType ats, Expr arg1, Expr arg2, bool fDontLift) 2550List<CandidateFunctionMember> candidateList, ExpressionKind ek, AggregateType type, 2571List<CandidateFunctionMember> candidateList, ExpressionKind ek, AggregateType type, 2587private ExprCall BindUDBinop(ExpressionKind ek, Expr arg1, Expr arg2, bool fDontLift, out MethPropWithInst ppmpwi) 2667private ExprCall BindLiftedUDBinop(ExpressionKind ek, Expr arg1, Expr arg2, TypeArray Params, MethPropWithInst mpwi) 2704case ExpressionKind.Eq: 2705case ExpressionKind.NotEq: 2711case ExpressionKind.GreaterThan: 2712case ExpressionKind.GreaterThanOrEqual: 2713case ExpressionKind.LessThan: 2714case ExpressionKind.LessThanOrEqual: 2723Debug.Assert(!(ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq) || nonLiftedArg1.Type == nonLiftedArg2.Type); 2734ExpressionKind.Eq => NullableCallLiftKind.EqualityOperator, 2736ExpressionKind.NotEq => NullableCallLiftKind.InequalityOperator, 2746private static AggregateType GetEnumBinOpType(ExpressionKind ek, CType argType1, CType argType2, out AggregateType ppEnumType) 2762case ExpressionKind.BitwiseAnd: 2763case ExpressionKind.BitwiseOr: 2764case ExpressionKind.BitwiseExclusiveOr: 2768case ExpressionKind.Add: 2772case ExpressionKind.Subtract: 2789private static ExprBinOp CreateBinopForPredefMethodCall(ExpressionKind ek, PREDEFMETH predefMeth, CType RetType, Expr arg1, Expr arg2) 2805private static ExprUnaryOp CreateUnaryOpForPredefMethodCall(ExpressionKind ek, PREDEFMETH predefMeth, CType pRetType, Expr pArg)

9: base(ExpressionKind.ArrayIndex, type)

9: base(ExpressionKind.ArrayInit, type)

11: base(ExpressionKind.Assignment)

10public ExprBinOp(ExpressionKind kind, CType type, Expr left, Expr right) 13Debug.Assert(kind > ExpressionKind.TypeLimit); 21public ExprBinOp(ExpressionKind kind, CType type, Expr left, Expr right, Expr call, MethPropWithInst userMethod) 24Debug.Assert(kind > ExpressionKind.TypeLimit);

11: base(ExpressionKind.BoundLambda, type)

11: base(ExpressionKind.Call, type)

12: base(ExpressionKind.Cast, type)

11: base(ExpressionKind.Class, type)

11: base(ExpressionKind.MultiGet, type) 24: base(ExpressionKind.Multi, type)

12: base(ExpressionKind.Concat, TypeFromOperands(first, second))

13: base(ExpressionKind.Constant, type)

13protected Expr(ExpressionKind kind) 22public ExpressionKind Kind { get; }

10protected ExprOperator(ExpressionKind kind, CType type) 13Debug.Assert(kind.IsUnaryOperator() || kind > ExpressionKind.TypeLimit); 16protected ExprOperator(ExpressionKind kind, CType type, Expr call, MethPropWithInst userDefinedMethod)

8protected ExprWithArgs(ExpressionKind kind, CType type)

10protected ExprWithType(ExpressionKind kind, CType type)

9: base(ExpressionKind.Field, type)

11: base(ExpressionKind.FieldInfo, type)

9: base(ExpressionKind.List)

11: base(ExpressionKind.Local)

12: base(ExpressionKind.MemberGroup, MethodGroupType.Instance)

15: base(ExpressionKind.MethodInfo, type)

13: base(ExpressionKind.NamedArgumentSpecification)

20: base(ExpressionKind.Property, type)

14: base(ExpressionKind.PropertyInfo, type)

9: base(ExpressionKind.Wrap)

11: base(ExpressionKind.TypeOf, type)

10public ExprUnaryOp(ExpressionKind kind, CType type, Expr operand) 18public ExprUnaryOp(ExpressionKind kind, CType type, Expr operand, Expr call, MethPropWithInst userMethod)

13: base(ExpressionKind.UserDefinedConversion)

11: base(ExpressionKind.UserLogicalOp, type)

381ExpressionKind.LeftShirt => PREDEFMETH.PM_EXPRESSION_LEFTSHIFT, 382ExpressionKind.RightShift => PREDEFMETH.PM_EXPRESSION_RIGHTSHIFT, 383ExpressionKind.BitwiseExclusiveOr => PREDEFMETH.PM_EXPRESSION_EXCLUSIVEOR, 384ExpressionKind.BitwiseOr => PREDEFMETH.PM_EXPRESSION_OR, 385ExpressionKind.BitwiseAnd => PREDEFMETH.PM_EXPRESSION_AND, 386ExpressionKind.LogicalAnd => PREDEFMETH.PM_EXPRESSION_ANDALSO, 387ExpressionKind.LogicalOr => PREDEFMETH.PM_EXPRESSION_ORELSE, 388ExpressionKind.StringEq => PREDEFMETH.PM_EXPRESSION_EQUAL, 389ExpressionKind.Eq => PREDEFMETH.PM_EXPRESSION_EQUAL, 390ExpressionKind.StringNotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL, 391ExpressionKind.NotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL, 392ExpressionKind.GreaterThanOrEqual => PREDEFMETH.PM_EXPRESSION_GREATERTHANOREQUAL, 393ExpressionKind.LessThanOrEqual => PREDEFMETH.PM_EXPRESSION_LESSTHANOREQUAL, 394ExpressionKind.LessThan => PREDEFMETH.PM_EXPRESSION_LESSTHAN, 395ExpressionKind.GreaterThan => PREDEFMETH.PM_EXPRESSION_GREATERTHAN, 396ExpressionKind.Modulo => PREDEFMETH.PM_EXPRESSION_MODULO, 397ExpressionKind.Divide => PREDEFMETH.PM_EXPRESSION_DIVIDE, 398ExpressionKind.Multiply => expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_MULTIPLYCHECKED : PREDEFMETH.PM_EXPRESSION_MULTIPLY, 399ExpressionKind.Subtract => expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_SUBTRACTCHECKED : PREDEFMETH.PM_EXPRESSION_SUBTRACT, 400ExpressionKind.Add => expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_ADDCHECKED : PREDEFMETH.PM_EXPRESSION_ADD, 482case ExpressionKind.UnaryPlus: 484case ExpressionKind.BitwiseNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT; break; 485case ExpressionKind.LogicalNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT; break; 486case ExpressionKind.Negate: 507case ExpressionKind.LogicalOr: pdm = PREDEFMETH.PM_EXPRESSION_ORELSE_USER_DEFINED; break; 508case ExpressionKind.LogicalAnd: pdm = PREDEFMETH.PM_EXPRESSION_ANDALSO_USER_DEFINED; break; 509case ExpressionKind.LeftShirt: pdm = PREDEFMETH.PM_EXPRESSION_LEFTSHIFT_USER_DEFINED; break; 510case ExpressionKind.RightShift: pdm = PREDEFMETH.PM_EXPRESSION_RIGHTSHIFT_USER_DEFINED; break; 511case ExpressionKind.BitwiseExclusiveOr: pdm = PREDEFMETH.PM_EXPRESSION_EXCLUSIVEOR_USER_DEFINED; break; 512case ExpressionKind.BitwiseOr: pdm = PREDEFMETH.PM_EXPRESSION_OR_USER_DEFINED; break; 513case ExpressionKind.BitwiseAnd: pdm = PREDEFMETH.PM_EXPRESSION_AND_USER_DEFINED; break; 514case ExpressionKind.Modulo: pdm = PREDEFMETH.PM_EXPRESSION_MODULO_USER_DEFINED; break; 515case ExpressionKind.Divide: pdm = PREDEFMETH.PM_EXPRESSION_DIVIDE_USER_DEFINED; break; 516case ExpressionKind.StringEq: 517case ExpressionKind.StringNotEq: 518case ExpressionKind.DelegateEq: 519case ExpressionKind.DelegateNotEq: 520case ExpressionKind.Eq: 521case ExpressionKind.NotEq: 522case ExpressionKind.GreaterThanOrEqual: 523case ExpressionKind.GreaterThan: 524case ExpressionKind.LessThanOrEqual: 525case ExpressionKind.LessThan: 527case ExpressionKind.DelegateSubtract: 528case ExpressionKind.Subtract: 531case ExpressionKind.DelegateAdd: 532case ExpressionKind.Add: 535case ExpressionKind.Multiply: 546Debug.Assert(udcall.Kind == ExpressionKind.Call || udcall.Kind == ExpressionKind.UserLogicalOp); 550Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List); 559Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List); 571if (expr.Kind == ExpressionKind.DelegateSubtract || expr.Kind == ExpressionKind.DelegateAdd) 593Debug.Assert(arg != null && arg.Kind != ExpressionKind.List); 596case ExpressionKind.True: 597case ExpressionKind.False: 599case ExpressionKind.UnaryPlus: 602case ExpressionKind.BitwiseNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT_USER_DEFINED; break; 603case ExpressionKind.LogicalNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT_USER_DEFINED; break; 604case ExpressionKind.DecimalNegate: 605case ExpressionKind.Negate: 609case ExpressionKind.Inc: 610case ExpressionKind.Dec: 611case ExpressionKind.DecimalInc: 612case ExpressionKind.DecimalDec: 622if (expr.Kind == ExpressionKind.Inc || expr.Kind == ExpressionKind.Dec || 623expr.Kind == ExpressionKind.DecimalInc || expr.Kind == ExpressionKind.DecimalDec) 637ExpressionKind.StringEq => PREDEFMETH.PM_EXPRESSION_EQUAL_USER_DEFINED, 638ExpressionKind.StringNotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL_USER_DEFINED, 639ExpressionKind.DelegateEq => PREDEFMETH.PM_EXPRESSION_EQUAL_USER_DEFINED, 640ExpressionKind.DelegateNotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL_USER_DEFINED, 641ExpressionKind.Eq => PREDEFMETH.PM_EXPRESSION_EQUAL_USER_DEFINED, 642ExpressionKind.NotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL_USER_DEFINED, 643ExpressionKind.LessThanOrEqual => PREDEFMETH.PM_EXPRESSION_LESSTHANOREQUAL_USER_DEFINED, 644ExpressionKind.LessThan => PREDEFMETH.PM_EXPRESSION_LESSTHAN_USER_DEFINED, 645ExpressionKind.GreaterThanOrEqual => PREDEFMETH.PM_EXPRESSION_GREATERTHANOREQUAL_USER_DEFINED, 646ExpressionKind.GreaterThan => PREDEFMETH.PM_EXPRESSION_GREATERTHAN_USER_DEFINED, 655Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List);

18ExpressionKind.BinaryOp => VisitBINOP(pExpr as ExprBinOp), 19ExpressionKind.UnaryOp => VisitUNARYOP(pExpr as ExprUnaryOp), 20ExpressionKind.Assignment => VisitASSIGNMENT(pExpr as ExprAssignment), 21ExpressionKind.List => VisitLIST(pExpr as ExprList), 22ExpressionKind.ArrayIndex => VisitARRAYINDEX(pExpr as ExprArrayIndex), 23ExpressionKind.Call => VisitCALL(pExpr as ExprCall), 24ExpressionKind.Field => VisitFIELD(pExpr as ExprField), 25ExpressionKind.Local => VisitLOCAL(pExpr as ExprLocal), 26ExpressionKind.Constant => VisitCONSTANT(pExpr as ExprConstant), 27ExpressionKind.Class => pExpr, 28ExpressionKind.Property => VisitPROP(pExpr as ExprProperty), 29ExpressionKind.Multi => VisitMULTI(pExpr as ExprMulti), 30ExpressionKind.MultiGet => VisitMULTIGET(pExpr as ExprMultiGet), 31ExpressionKind.Wrap => VisitWRAP(pExpr as ExprWrap), 32ExpressionKind.Concat => VisitCONCAT(pExpr as ExprConcat), 33ExpressionKind.ArrayInit => VisitARRINIT(pExpr as ExprArrayInit), 34ExpressionKind.Cast => VisitCAST(pExpr as ExprCast), 35ExpressionKind.UserDefinedConversion => VisitUSERDEFINEDCONVERSION(pExpr as ExprUserDefinedConversion), 36ExpressionKind.TypeOf => VisitTYPEOF(pExpr as ExprTypeOf), 37ExpressionKind.ZeroInit => VisitZEROINIT(pExpr as ExprZeroInit), 38ExpressionKind.UserLogicalOp => VisitUSERLOGOP(pExpr as ExprUserLogicalOp), 39ExpressionKind.MemberGroup => VisitMEMGRP(pExpr as ExprMemberGroup), 40ExpressionKind.FieldInfo => VisitFIELDINFO(pExpr as ExprFieldInfo), 41ExpressionKind.MethodInfo => VisitMETHODINFO(pExpr as ExprMethodInfo), 44ExpressionKind.EqualsParam => VisitEQUALS(pExpr as ExprBinOp), 45ExpressionKind.Compare => VisitCOMPARE(pExpr as ExprBinOp), 46ExpressionKind.NotEq => VisitNE(pExpr as ExprBinOp), 47ExpressionKind.LessThan => VisitLT(pExpr as ExprBinOp), 48ExpressionKind.LessThanOrEqual => VisitLE(pExpr as ExprBinOp), 49ExpressionKind.GreaterThan => VisitGT(pExpr as ExprBinOp), 50ExpressionKind.GreaterThanOrEqual => VisitGE(pExpr as ExprBinOp), 51ExpressionKind.Add => VisitADD(pExpr as ExprBinOp), 52ExpressionKind.Subtract => VisitSUB(pExpr as ExprBinOp), 53ExpressionKind.Multiply => VisitMUL(pExpr as ExprBinOp), 54ExpressionKind.Divide => VisitDIV(pExpr as ExprBinOp), 55ExpressionKind.Modulo => VisitMOD(pExpr as ExprBinOp), 56ExpressionKind.BitwiseAnd => VisitBITAND(pExpr as ExprBinOp), 57ExpressionKind.BitwiseOr => VisitBITOR(pExpr as ExprBinOp), 58ExpressionKind.BitwiseExclusiveOr => VisitBITXOR(pExpr as ExprBinOp), 59ExpressionKind.LeftShirt => VisitLSHIFT(pExpr as ExprBinOp), 60ExpressionKind.RightShift => VisitRSHIFT(pExpr as ExprBinOp), 61ExpressionKind.LogicalAnd => VisitLOGAND(pExpr as ExprBinOp), 62ExpressionKind.LogicalOr => VisitLOGOR(pExpr as ExprBinOp), 63ExpressionKind.Sequence => VisitSEQUENCE(pExpr as ExprBinOp), 64ExpressionKind.Save => VisitSAVE(pExpr as ExprBinOp), 65ExpressionKind.Swap => VisitSWAP(pExpr as ExprBinOp), 66ExpressionKind.Indir => VisitINDIR(pExpr as ExprBinOp), 67ExpressionKind.StringEq => VisitSTRINGEQ(pExpr as ExprBinOp), 68ExpressionKind.StringNotEq => VisitSTRINGNE(pExpr as ExprBinOp), 69ExpressionKind.DelegateEq => VisitDELEGATEEQ(pExpr as ExprBinOp), 70ExpressionKind.DelegateNotEq => VisitDELEGATENE(pExpr as ExprBinOp), 71ExpressionKind.DelegateAdd => VisitDELEGATEADD(pExpr as ExprBinOp), 72ExpressionKind.DelegateSubtract => VisitDELEGATESUB(pExpr as ExprBinOp), 73ExpressionKind.Eq => VisitEQ(pExpr as ExprBinOp), 76ExpressionKind.True => VisitTRUE(pExpr as ExprUnaryOp), 77ExpressionKind.False => VisitFALSE(pExpr as ExprUnaryOp), 78ExpressionKind.Inc => VisitINC(pExpr as ExprUnaryOp), 79ExpressionKind.Dec => VisitDEC(pExpr as ExprUnaryOp), 80ExpressionKind.LogicalNot => VisitLOGNOT(pExpr as ExprUnaryOp), 81ExpressionKind.Negate => VisitNEG(pExpr as ExprUnaryOp), 82ExpressionKind.UnaryPlus => VisitUPLUS(pExpr as ExprUnaryOp), 83ExpressionKind.BitwiseNot => VisitBITNOT(pExpr as ExprUnaryOp), 84ExpressionKind.Addr => VisitADDR(pExpr as ExprUnaryOp), 85ExpressionKind.DecimalNegate => VisitDECIMALNEG(pExpr as ExprUnaryOp), 86ExpressionKind.DecimalInc => VisitDECIMALINC(pExpr as ExprUnaryOp), 87ExpressionKind.DecimalDec => VisitDECIMALDEC(pExpr as ExprUnaryOp), 100case ExpressionKind.List: 123case ExpressionKind.Assignment: 132case ExpressionKind.ArrayIndex: 141case ExpressionKind.UnaryOp: 142case ExpressionKind.True: 143case ExpressionKind.False: 144case ExpressionKind.Inc: 145case ExpressionKind.Dec: 146case ExpressionKind.LogicalNot: 147case ExpressionKind.Negate: 148case ExpressionKind.UnaryPlus: 149case ExpressionKind.BitwiseNot: 150case ExpressionKind.Addr: 151case ExpressionKind.DecimalNegate: 152case ExpressionKind.DecimalInc: 153case ExpressionKind.DecimalDec: 159case ExpressionKind.UserLogicalOp: 171case ExpressionKind.TypeOf: 174case ExpressionKind.Cast: 180case ExpressionKind.UserDefinedConversion: 186case ExpressionKind.ZeroInit: 189case ExpressionKind.MemberGroup: 196case ExpressionKind.Call: 204case ExpressionKind.Property: 212case ExpressionKind.Field: 217case ExpressionKind.Constant: 252case ExpressionKind.Multi: 261case ExpressionKind.Concat: 270case ExpressionKind.ArrayInit: 277case ExpressionKind.Local: 278case ExpressionKind.Class: 279case ExpressionKind.MultiGet: 280case ExpressionKind.Wrap: 281case ExpressionKind.NoOp: 282case ExpressionKind.FieldInfo: 283case ExpressionKind.MethodInfo:

12: base(ExpressionKind.ZeroInit, type)