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

963?? _binder.bindUDUnop(op == OperatorKind.OP_TRUE ? ExpressionKind.True : ExpressionKind.False, arg1) 987ExpressionKind ek = Operators.GetExpressionKind(GetOperatorKind(payload.Operation, payload.IsLogicalOperation)); 994if (ek > ExpressionKind.MultiOffset) 996ek = (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); 537internal Expr bindUDUnop(ExpressionKind ek, Expr arg) 870case ExpressionKind.Property: 898case ExpressionKind.Field: 1052(((pObject.Flags & EXPRFLAG.EXF_LVALUE) != 0) && (pObject.Kind != ExpressionKind.Property)) || 1605private static Name ExpressionKindName(ExpressionKind ek) 1607Debug.Assert(ek >= ExpressionKind.FirstOp && (ek - ExpressionKind.FirstOp) < (int)EK2NAME.Length); 1608return 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:

152public static ExprBinOp CreateBinop(ExpressionKind exprKind, CType type, Expr left, Expr right) => 155public static ExprUnaryOp CreateUnaryOp(ExpressionKind exprKind, CType type, Expr operand) => 158public static ExprOperator CreateOperator(ExpressionKind exprKind, CType type, Expr arg1, Expr arg2) 167public static ExprBinOp CreateUserDefinedBinop(ExpressionKind exprKind, CType type, Expr left, Expr right, Expr call, MethPropWithInst userMethod) => 171public static ExprUnaryOp CreateUserDefinedUnaryOperator(ExpressionKind exprKind, CType type, Expr operand, ExprCall call, MethPropWithInst userMethod) => 177ExprUnaryOp unary = CreateUnaryOp(ExpressionKind.Negate, operand.Type, operand); 186CreateBinop(ExpressionKind.Sequence, second.Type, first, second); 203ExprBinOp expr = CreateBinop(ExpressionKind.Save, wrap.Type, wrap.OptionalExpression, wrap); 224if (first.Kind != ExpressionKind.List) 232Debug.Assert((last as ExprList).OptionalNextListNode.Kind != ExpressionKind.List);

138private ExprBinOp BindUserDefinedBinOp(ExpressionKind ek, BinOpArgInfo info) 151ek - ExpressionKind.LogicalAnd + ExpressionKind.BitwiseAnd, info.arg1, info.arg2, true, out pmpwi); 452private static ExprBinOp BindNullEqualityComparison(ExpressionKind ek, BinOpArgInfo info) 486public Expr BindStandardBinop(ExpressionKind ek, Expr arg1, Expr arg2) 561private Expr BindStandardBinopCore(BinOpArgInfo info, BinOpFullSig bofs, ExpressionKind ek, EXPRFLAG flags) 603private ExprBinOp BindLiftedStandardBinOp(BinOpArgInfo info, BinOpFullSig bofs, ExpressionKind ek, EXPRFLAG flags) 896private static bool IsEnumArithmeticBinOp(ExpressionKind ek, BinOpArgInfo info) => 899ExpressionKind.Add => info.typeRaw1.IsEnumType ^ info.typeRaw2.IsEnumType, 900ExpressionKind.Subtract => info.typeRaw1.IsEnumType | info.typeRaw2.IsEnumType, 1076private static (ExpressionKind, UnaOpKind, EXPRFLAG) CalculateExprAndUnaryOpKinds(OperatorKind op, bool bChecked) 1078ExpressionKind ek; 1085ek = ExpressionKind.UnaryPlus; 1094ek = ExpressionKind.Negate; 1099ek = ExpressionKind.BitwiseNot; 1104ek = ExpressionKind.LogicalNot; 1114ek = ExpressionKind.Add; 1123ek = ExpressionKind.Add; 1133ek = ExpressionKind.Subtract; 1142ek = ExpressionKind.Subtract; 1178(ExpressionKind ek, UnaOpKind unaryOpKind, EXPRFLAG flags) = 1296private UnaryOperatorSignatureFindResult PopulateSignatureList(Expr pArgument, UnaOpKind unaryOpKind, UnaOpMask unaryOpMask, ExpressionKind exprKind, EXPRFLAG flags, List<UnaOpFullSig> pSignatures, out Expr ppResult) 1350Expr exprVal = bindUDUnop((ExpressionKind)(exprKind - ExpressionKind.Add + ExpressionKind.Inc), exprGet); 1513private ExprOperator BindLiftedStandardUnop(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1565private static ExprOperator BindIntBinOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1575private static ExprOperator BindIntUnaOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg) 1585private static ExprOperator BindRealBinOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG _, Expr arg1, Expr arg2) 1595private static ExprOperator BindRealUnaOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG _, Expr arg) 1606private Expr BindIncOp(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1608Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1630private Expr BindIncOpCore(ExpressionKind ek, EXPRFLAG flags, Expr exprVal, CType type) 1632Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1647if (ek == ExpressionKind.Add) 1649ek = ExpressionKind.DecimalInc; 1654ek = ExpressionKind.DecimalDec; 1688private Expr LScalar(ExpressionKind ek, EXPRFLAG flags, Expr exprVal, CType type, ConstVal cv, CType typeTmp) 1702private ExprMulti BindNonliftedIncOp(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1704Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1729private ExprMulti BindLiftedIncOp(ExpressionKind ek, EXPRFLAG flags, Expr arg, UnaOpFullSig uofs) 1731Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 1747ExprUnaryOp exprRes = ExprFactory.CreateUnaryOp((ek == ExpressionKind.Add) ? ExpressionKind.Inc : ExpressionKind.Dec, arg.Type/* type */, exprVal); 1763private static ExprBinOp BindDecBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1778case ExpressionKind.Add: 1779case ExpressionKind.Subtract: 1780case ExpressionKind.Multiply: 1781case ExpressionKind.Divide: 1782case ExpressionKind.Modulo: 1785case ExpressionKind.LessThan: 1786case ExpressionKind.LessThanOrEqual: 1787case ExpressionKind.GreaterThan: 1788case ExpressionKind.GreaterThanOrEqual: 1789case ExpressionKind.Eq: 1790case ExpressionKind.NotEq: 1805private static ExprUnaryOp BindDecUnaOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg) 1808Debug.Assert(ek == ExpressionKind.Negate || ek == ExpressionKind.UnaryPlus); 1813if (ek == ExpressionKind.Negate) 1816return CreateUnaryOpForPredefMethodCall(ExpressionKind.DecimalNegate, predefMeth, typeDec, arg); 1818return ExprFactory.CreateUnaryOp(ExpressionKind.UnaryPlus, typeDec, arg); 1825private static Expr BindStrBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1827Debug.Assert(ek == ExpressionKind.Add); 1837private static ExprBinOp BindShiftOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1839Debug.Assert(ek == ExpressionKind.LeftShirt || ek == ExpressionKind.RightShift); 1855private static ExprBinOp BindBoolBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1866private ExprOperator BindBoolBitwiseOp(ExpressionKind ek, EXPRFLAG flags, Expr expr1, Expr expr2) 1868Debug.Assert(ek == ExpressionKind.BitwiseAnd || ek == ExpressionKind.BitwiseOr); 1903private static Expr BindLiftedBoolBitwiseOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr expr1, Expr expr2) => null; 1910private static Expr BindBoolUnaOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg) 1913Debug.Assert(ek == ExpressionKind.LogicalNot); 1924return ExprFactory.CreateUnaryOp(ExpressionKind.LogicalNot, typeBool, arg); 1935private static ExprBinOp BindStrCmpOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1937Debug.Assert(ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq); 1943PREDEFMETH predefMeth = ek == ExpressionKind.Eq ? PREDEFMETH.PM_STRING_OPEQUALITY : PREDEFMETH.PM_STRING_OPINEQUALITY; 1944ek = ek == ExpressionKind.Eq ? ExpressionKind.StringEq : ExpressionKind.StringNotEq; 1953private static ExprBinOp BindRefCmpOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1955Debug.Assert(ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq); 1969private static Expr BindDelBinOp(ExpressionBinder _, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 1971Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract || ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq); 1978case ExpressionKind.Add: 1981ek = ExpressionKind.DelegateAdd; 1984case ExpressionKind.Subtract: 1987ek = ExpressionKind.DelegateSubtract; 1990case ExpressionKind.Eq: 1993ek = ExpressionKind.DelegateEq; 1996case ExpressionKind.NotEq: 1999ek = ExpressionKind.DelegateNotEq; 2010private static Expr BindEnumBinOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 2039private Expr BindLiftedEnumArithmeticBinOp(ExpressionKind ek, EXPRFLAG flags, Expr arg1, Expr arg2) 2041Debug.Assert(ek == ExpressionKind.Add || ek == ExpressionKind.Subtract); 2086private static Expr BindEnumUnaOp(ExpressionBinder binder, ExpressionKind ek, EXPRFLAG flags, Expr arg) 2088Debug.Assert(ek == ExpressionKind.BitwiseNot); 2110private (BinOpKind, EXPRFLAG) GetBinopKindAndFlags(ExpressionKind ek) 2116case ExpressionKind.Add: 2123case ExpressionKind.Subtract: 2130case ExpressionKind.Divide: 2131case ExpressionKind.Modulo: 2141case ExpressionKind.Multiply: 2148case ExpressionKind.BitwiseAnd: 2149case ExpressionKind.BitwiseOr: 2152case ExpressionKind.BitwiseExclusiveOr: 2155case ExpressionKind.LeftShirt: 2156case ExpressionKind.RightShift: 2159case ExpressionKind.LogicalOr: 2160case ExpressionKind.LogicalAnd: 2163case ExpressionKind.LessThan: 2164case ExpressionKind.LessThanOrEqual: 2165case ExpressionKind.GreaterThan: 2166case ExpressionKind.GreaterThanOrEqual: 2169case ExpressionKind.Eq: 2170case ExpressionKind.NotEq: 2187private ExprOperator BindIntOp(ExpressionKind kind, EXPRFLAG flags, Expr op1, Expr op2, PredefinedType ptOp) 2195Debug.Assert((op2 == null) == (kind == ExpressionKind.Negate || kind == ExpressionKind.UnaryPlus || kind == ExpressionKind.BitwiseNot)); 2197if (kind == ExpressionKind.Negate) 2272private static ExprOperator BindFloatOp(ExpressionKind kind, Expr op1, Expr op2) 2330private Expr BindUserBoolOp(ExpressionKind kind, ExprCall pCall) 2335Debug.Assert(kind == ExpressionKind.LogicalAnd || kind == ExpressionKind.LogicalOr); 2357Expr pCallT = bindUDUnop(ExpressionKind.True, pExprWrap); 2358Expr pCallF = bindUDUnop(ExpressionKind.False, pExprWrap); 2367return ExprFactory.CreateUserLogOp(typeRet, kind == ExpressionKind.LogicalAnd ? pCallF : pCallT, pCall); 2406private static bool UserDefinedBinaryOperatorCanBeLifted(ExpressionKind ek, MethodSymbol method, AggregateType ats, 2422case ExpressionKind.Eq: 2423case ExpressionKind.NotEq: 2433case ExpressionKind.GreaterThan: 2434case ExpressionKind.GreaterThanOrEqual: 2435case ExpressionKind.LessThan: 2436case ExpressionKind.LessThanOrEqual: 2451ExpressionKind ek, MethodSymbol method, AggregateType ats, Expr arg1, Expr arg2, bool fDontLift) 2489List<CandidateFunctionMember> candidateList, ExpressionKind ek, AggregateType type, 2509List<CandidateFunctionMember> candidateList, ExpressionKind ek, AggregateType type, 2524private ExprCall BindUDBinop(ExpressionKind ek, Expr arg1, Expr arg2, bool fDontLift, out MethPropWithInst ppmpwi) 2602private ExprCall BindLiftedUDBinop(ExpressionKind ek, Expr arg1, Expr arg2, TypeArray Params, MethPropWithInst mpwi) 2639case ExpressionKind.Eq: 2640case ExpressionKind.NotEq: 2646case ExpressionKind.GreaterThan: 2647case ExpressionKind.GreaterThanOrEqual: 2648case ExpressionKind.LessThan: 2649case ExpressionKind.LessThanOrEqual: 2658Debug.Assert(!(ek == ExpressionKind.Eq || ek == ExpressionKind.NotEq) || nonLiftedArg1.Type == nonLiftedArg2.Type); 2669ExpressionKind.Eq => NullableCallLiftKind.EqualityOperator, 2671ExpressionKind.NotEq => NullableCallLiftKind.InequalityOperator, 2680private static AggregateType GetEnumBinOpType(ExpressionKind ek, CType argType1, CType argType2, out AggregateType ppEnumType) 2696case ExpressionKind.BitwiseAnd: 2697case ExpressionKind.BitwiseOr: 2698case ExpressionKind.BitwiseExclusiveOr: 2702case ExpressionKind.Add: 2706case ExpressionKind.Subtract: 2722private static ExprBinOp CreateBinopForPredefMethodCall(ExpressionKind ek, PREDEFMETH predefMeth, CType RetType, Expr arg1, Expr arg2) 2737private 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)

14: 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)

380ExpressionKind.LeftShirt => PREDEFMETH.PM_EXPRESSION_LEFTSHIFT, 381ExpressionKind.RightShift => PREDEFMETH.PM_EXPRESSION_RIGHTSHIFT, 382ExpressionKind.BitwiseExclusiveOr => PREDEFMETH.PM_EXPRESSION_EXCLUSIVEOR, 383ExpressionKind.BitwiseOr => PREDEFMETH.PM_EXPRESSION_OR, 384ExpressionKind.BitwiseAnd => PREDEFMETH.PM_EXPRESSION_AND, 385ExpressionKind.LogicalAnd => PREDEFMETH.PM_EXPRESSION_ANDALSO, 386ExpressionKind.LogicalOr => PREDEFMETH.PM_EXPRESSION_ORELSE, 387ExpressionKind.StringEq => PREDEFMETH.PM_EXPRESSION_EQUAL, 388ExpressionKind.Eq => PREDEFMETH.PM_EXPRESSION_EQUAL, 389ExpressionKind.StringNotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL, 390ExpressionKind.NotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL, 391ExpressionKind.GreaterThanOrEqual => PREDEFMETH.PM_EXPRESSION_GREATERTHANOREQUAL, 392ExpressionKind.LessThanOrEqual => PREDEFMETH.PM_EXPRESSION_LESSTHANOREQUAL, 393ExpressionKind.LessThan => PREDEFMETH.PM_EXPRESSION_LESSTHAN, 394ExpressionKind.GreaterThan => PREDEFMETH.PM_EXPRESSION_GREATERTHAN, 395ExpressionKind.Modulo => PREDEFMETH.PM_EXPRESSION_MODULO, 396ExpressionKind.Divide => PREDEFMETH.PM_EXPRESSION_DIVIDE, 397ExpressionKind.Multiply => expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_MULTIPLYCHECKED : PREDEFMETH.PM_EXPRESSION_MULTIPLY, 398ExpressionKind.Subtract => expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_SUBTRACTCHECKED : PREDEFMETH.PM_EXPRESSION_SUBTRACT, 399ExpressionKind.Add => expr.isChecked() ? PREDEFMETH.PM_EXPRESSION_ADDCHECKED : PREDEFMETH.PM_EXPRESSION_ADD, 481case ExpressionKind.UnaryPlus: 483case ExpressionKind.BitwiseNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT; break; 484case ExpressionKind.LogicalNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT; break; 485case ExpressionKind.Negate: 506case ExpressionKind.LogicalOr: pdm = PREDEFMETH.PM_EXPRESSION_ORELSE_USER_DEFINED; break; 507case ExpressionKind.LogicalAnd: pdm = PREDEFMETH.PM_EXPRESSION_ANDALSO_USER_DEFINED; break; 508case ExpressionKind.LeftShirt: pdm = PREDEFMETH.PM_EXPRESSION_LEFTSHIFT_USER_DEFINED; break; 509case ExpressionKind.RightShift: pdm = PREDEFMETH.PM_EXPRESSION_RIGHTSHIFT_USER_DEFINED; break; 510case ExpressionKind.BitwiseExclusiveOr: pdm = PREDEFMETH.PM_EXPRESSION_EXCLUSIVEOR_USER_DEFINED; break; 511case ExpressionKind.BitwiseOr: pdm = PREDEFMETH.PM_EXPRESSION_OR_USER_DEFINED; break; 512case ExpressionKind.BitwiseAnd: pdm = PREDEFMETH.PM_EXPRESSION_AND_USER_DEFINED; break; 513case ExpressionKind.Modulo: pdm = PREDEFMETH.PM_EXPRESSION_MODULO_USER_DEFINED; break; 514case ExpressionKind.Divide: pdm = PREDEFMETH.PM_EXPRESSION_DIVIDE_USER_DEFINED; break; 515case ExpressionKind.StringEq: 516case ExpressionKind.StringNotEq: 517case ExpressionKind.DelegateEq: 518case ExpressionKind.DelegateNotEq: 519case ExpressionKind.Eq: 520case ExpressionKind.NotEq: 521case ExpressionKind.GreaterThanOrEqual: 522case ExpressionKind.GreaterThan: 523case ExpressionKind.LessThanOrEqual: 524case ExpressionKind.LessThan: 526case ExpressionKind.DelegateSubtract: 527case ExpressionKind.Subtract: 530case ExpressionKind.DelegateAdd: 531case ExpressionKind.Add: 534case ExpressionKind.Multiply: 545Debug.Assert(udcall.Kind == ExpressionKind.Call || udcall.Kind == ExpressionKind.UserLogicalOp); 549Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List); 558Debug.Assert(args.OptionalNextListNode.Kind != ExpressionKind.List); 570if (expr.Kind == ExpressionKind.DelegateSubtract || expr.Kind == ExpressionKind.DelegateAdd) 592Debug.Assert(arg != null && arg.Kind != ExpressionKind.List); 595case ExpressionKind.True: 596case ExpressionKind.False: 598case ExpressionKind.UnaryPlus: 601case ExpressionKind.BitwiseNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT_USER_DEFINED; break; 602case ExpressionKind.LogicalNot: pdm = PREDEFMETH.PM_EXPRESSION_NOT_USER_DEFINED; break; 603case ExpressionKind.DecimalNegate: 604case ExpressionKind.Negate: 608case ExpressionKind.Inc: 609case ExpressionKind.Dec: 610case ExpressionKind.DecimalInc: 611case ExpressionKind.DecimalDec: 621if (expr.Kind == ExpressionKind.Inc || expr.Kind == ExpressionKind.Dec || 622expr.Kind == ExpressionKind.DecimalInc || expr.Kind == ExpressionKind.DecimalDec) 636ExpressionKind.StringEq => PREDEFMETH.PM_EXPRESSION_EQUAL_USER_DEFINED, 637ExpressionKind.StringNotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL_USER_DEFINED, 638ExpressionKind.DelegateEq => PREDEFMETH.PM_EXPRESSION_EQUAL_USER_DEFINED, 639ExpressionKind.DelegateNotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL_USER_DEFINED, 640ExpressionKind.Eq => PREDEFMETH.PM_EXPRESSION_EQUAL_USER_DEFINED, 641ExpressionKind.NotEq => PREDEFMETH.PM_EXPRESSION_NOTEQUAL_USER_DEFINED, 642ExpressionKind.LessThanOrEqual => PREDEFMETH.PM_EXPRESSION_LESSTHANOREQUAL_USER_DEFINED, 643ExpressionKind.LessThan => PREDEFMETH.PM_EXPRESSION_LESSTHAN_USER_DEFINED, 644ExpressionKind.GreaterThanOrEqual => PREDEFMETH.PM_EXPRESSION_GREATERTHANOREQUAL_USER_DEFINED, 645ExpressionKind.GreaterThan => PREDEFMETH.PM_EXPRESSION_GREATERTHAN_USER_DEFINED, 654Debug.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)