1 // Licensed to the .NET Foundation under one or more agreements.
2 // The .NET Foundation licenses this file to you under the MIT license.
3 // See the LICENSE file in the project root for more information.
4 
5 using System.Diagnostics;
6 
7 namespace Microsoft.CSharp.RuntimeBinder.Semantics
8 {
9     internal abstract class ExprVisitorBase
10     {
Visit(Expr pExpr)11         public Expr Visit(Expr pExpr)
12         {
13             if (pExpr == null)
14             {
15                 return null;
16             }
17 
18             Expr pResult;
19             if (IsCachedExpr(pExpr, out pResult))
20             {
21                 return pResult;
22             }
23 
24             return CacheExprMapping(pExpr, Dispatch(pExpr));
25         }
26 
IsCachedExpr(Expr pExpr, out Expr pTransformedExpr)27         private bool IsCachedExpr(Expr pExpr, out Expr pTransformedExpr)
28         {
29             pTransformedExpr = null;
30             return false;
31         }
32 
33         /////////////////////////////////////////////////////////////////////////////////
34 
CacheExprMapping(Expr pExpr, Expr pTransformedExpr)35         private Expr CacheExprMapping(Expr pExpr, Expr pTransformedExpr)
36         {
37             return pTransformedExpr;
38         }
39 
Dispatch(Expr pExpr)40         protected virtual Expr Dispatch(Expr pExpr)
41         {
42             switch (pExpr.Kind)
43             {
44                 case ExpressionKind.BinaryOp:
45                     return VisitBINOP(pExpr as ExprBinOp);
46                 case ExpressionKind.UnaryOp:
47                     return VisitUNARYOP(pExpr as ExprUnaryOp);
48                 case ExpressionKind.Assignment:
49                     return VisitASSIGNMENT(pExpr as ExprAssignment);
50                 case ExpressionKind.List:
51                     return VisitLIST(pExpr as ExprList);
52                 case ExpressionKind.ArrayIndex:
53                     return VisitARRAYINDEX(pExpr as ExprArrayIndex);
54                 case ExpressionKind.Call:
55                     return VisitCALL(pExpr as ExprCall);
56                 case ExpressionKind.Field:
57                     return VisitFIELD(pExpr as ExprField);
58                 case ExpressionKind.Local:
59                     return VisitLOCAL(pExpr as ExprLocal);
60                 case ExpressionKind.Constant:
61                     return VisitCONSTANT(pExpr as ExprConstant);
62                 case ExpressionKind.Class:
63                     return pExpr;
64                 case ExpressionKind.Property:
65                     return VisitPROP(pExpr as ExprProperty);
66                 case ExpressionKind.Multi:
67                     return VisitMULTI(pExpr as ExprMulti);
68                 case ExpressionKind.MultiGet:
69                     return VisitMULTIGET(pExpr as ExprMultiGet);
70                 case ExpressionKind.Wrap:
71                     return VisitWRAP(pExpr as ExprWrap);
72                 case ExpressionKind.Concat:
73                     return VisitCONCAT(pExpr as ExprConcat);
74                 case ExpressionKind.ArrayInit:
75                     return VisitARRINIT(pExpr as ExprArrayInit);
76                 case ExpressionKind.Cast:
77                     return VisitCAST(pExpr as ExprCast);
78                 case ExpressionKind.UserDefinedConversion:
79                     return VisitUSERDEFINEDCONVERSION(pExpr as ExprUserDefinedConversion);
80                 case ExpressionKind.TypeOf:
81                     return VisitTYPEOF(pExpr as ExprTypeOf);
82                 case ExpressionKind.ZeroInit:
83                     return VisitZEROINIT(pExpr as ExprZeroInit);
84                 case ExpressionKind.UserLogicalOp:
85                     return VisitUSERLOGOP(pExpr as ExprUserLogicalOp);
86                 case ExpressionKind.MemberGroup:
87                     return VisitMEMGRP(pExpr as ExprMemberGroup);
88                 case ExpressionKind.FieldInfo:
89                     return VisitFIELDINFO(pExpr as ExprFieldInfo);
90                 case ExpressionKind.MethodInfo:
91                     return VisitMETHODINFO(pExpr as ExprMethodInfo);
92 
93                 // Binary operators
94                 case ExpressionKind.EqualsParam:
95                     return VisitEQUALS(pExpr as ExprBinOp);
96                 case ExpressionKind.Compare:
97                     return VisitCOMPARE(pExpr as ExprBinOp);
98                 case ExpressionKind.NotEq:
99                     return VisitNE(pExpr as ExprBinOp);
100                 case ExpressionKind.LessThan:
101                     return VisitLT(pExpr as ExprBinOp);
102                 case ExpressionKind.LessThanOrEqual:
103                     return VisitLE(pExpr as ExprBinOp);
104                 case ExpressionKind.GreaterThan:
105                     return VisitGT(pExpr as ExprBinOp);
106                 case ExpressionKind.GreaterThanOrEqual:
107                     return VisitGE(pExpr as ExprBinOp);
108                 case ExpressionKind.Add:
109                     return VisitADD(pExpr as ExprBinOp);
110                 case ExpressionKind.Subtract:
111                     return VisitSUB(pExpr as ExprBinOp);
112                 case ExpressionKind.Multiply:
113                     return VisitMUL(pExpr as ExprBinOp);
114                 case ExpressionKind.Divide:
115                     return VisitDIV(pExpr as ExprBinOp);
116                 case ExpressionKind.Modulo:
117                     return VisitMOD(pExpr as ExprBinOp);
118                 case ExpressionKind.BitwiseAnd:
119                     return VisitBITAND(pExpr as ExprBinOp);
120                 case ExpressionKind.BitwiseOr:
121                     return VisitBITOR(pExpr as ExprBinOp);
122                 case ExpressionKind.BitwiseExclusiveOr:
123                     return VisitBITXOR(pExpr as ExprBinOp);
124                 case ExpressionKind.LeftShirt:
125                     return VisitLSHIFT(pExpr as ExprBinOp);
126                 case ExpressionKind.RightShift:
127                     return VisitRSHIFT(pExpr as ExprBinOp);
128                 case ExpressionKind.LogicalAnd:
129                     return VisitLOGAND(pExpr as ExprBinOp);
130                 case ExpressionKind.LogicalOr:
131                     return VisitLOGOR(pExpr as ExprBinOp);
132                 case ExpressionKind.Sequence:
133                     return VisitSEQUENCE(pExpr as ExprBinOp);
134                 case ExpressionKind.Save:
135                     return VisitSAVE(pExpr as ExprBinOp);
136                 case ExpressionKind.Swap:
137                     return VisitSWAP(pExpr as ExprBinOp);
138                 case ExpressionKind.Indir:
139                     return VisitINDIR(pExpr as ExprBinOp);
140                 case ExpressionKind.StringEq:
141                     return VisitSTRINGEQ(pExpr as ExprBinOp);
142                 case ExpressionKind.StringNotEq:
143                     return VisitSTRINGNE(pExpr as ExprBinOp);
144                 case ExpressionKind.DelegateEq:
145                     return VisitDELEGATEEQ(pExpr as ExprBinOp);
146                 case ExpressionKind.DelegateNotEq:
147                     return VisitDELEGATENE(pExpr as ExprBinOp);
148                 case ExpressionKind.DelegateAdd:
149                     return VisitDELEGATEADD(pExpr as ExprBinOp);
150                 case ExpressionKind.DelegateSubtract:
151                     return VisitDELEGATESUB(pExpr as ExprBinOp);
152                 case ExpressionKind.Eq:
153                     return VisitEQ(pExpr as ExprBinOp);
154 
155                 // Unary operators
156                 case ExpressionKind.True:
157                     return VisitTRUE(pExpr as ExprUnaryOp);
158                 case ExpressionKind.False:
159                     return VisitFALSE(pExpr as ExprUnaryOp);
160                 case ExpressionKind.Inc:
161                     return VisitINC(pExpr as ExprUnaryOp);
162                 case ExpressionKind.Dec:
163                     return VisitDEC(pExpr as ExprUnaryOp);
164                 case ExpressionKind.LogicalNot:
165                     return VisitLOGNOT(pExpr as ExprUnaryOp);
166                 case ExpressionKind.Negate:
167                     return VisitNEG(pExpr as ExprUnaryOp);
168                 case ExpressionKind.UnaryPlus:
169                     return VisitUPLUS(pExpr as ExprUnaryOp);
170                 case ExpressionKind.BitwiseNot:
171                     return VisitBITNOT(pExpr as ExprUnaryOp);
172                 case ExpressionKind.Addr:
173                     return VisitADDR(pExpr as ExprUnaryOp);
174                 case ExpressionKind.DecimalNegate:
175                     return VisitDECIMALNEG(pExpr as ExprUnaryOp);
176                 case ExpressionKind.DecimalInc:
177                     return VisitDECIMALINC(pExpr as ExprUnaryOp);
178                 case ExpressionKind.DecimalDec:
179                     return VisitDECIMALDEC(pExpr as ExprUnaryOp);
180                 default:
181                     throw Error.InternalCompilerError();
182             }
183         }
184 
VisitChildren(Expr pExpr)185         private void VisitChildren(Expr pExpr)
186         {
187             Debug.Assert(pExpr != null);
188 
189             Expr exprRet;
190 
191             switch (pExpr.Kind)
192             {
193                 case ExpressionKind.List:
194 
195                     // Lists are a special case.  We treat a list not as a
196                     // binary node but rather as a node with n children.
197                     ExprList list = (ExprList)pExpr;
198                     while (true)
199                     {
200                         list.OptionalElement = Visit(list.OptionalElement);
201                         Expr nextNode = list.OptionalNextListNode;
202                         if (nextNode == null)
203                         {
204                             return;
205                         }
206 
207                         if (!(nextNode is ExprList next))
208                         {
209                             list.OptionalNextListNode = Visit(nextNode);
210                             return;
211                         }
212 
213                         list = next;
214                     }
215 
216                 case ExpressionKind.Assignment:
217                     exprRet = Visit((pExpr as ExprAssignment).LHS);
218                     Debug.Assert(exprRet != null);
219                     (pExpr as ExprAssignment).LHS = exprRet;
220                     exprRet = Visit((pExpr as ExprAssignment).RHS);
221                     Debug.Assert(exprRet != null);
222                     (pExpr as ExprAssignment).RHS = exprRet;
223                     break;
224 
225                 case ExpressionKind.ArrayIndex:
226                     exprRet = Visit((pExpr as ExprArrayIndex).Array);
227                     Debug.Assert(exprRet != null);
228                     (pExpr as ExprArrayIndex).Array = exprRet;
229                     exprRet = Visit((pExpr as ExprArrayIndex).Index);
230                     Debug.Assert(exprRet != null);
231                     (pExpr as ExprArrayIndex).Index = exprRet;
232                     break;
233 
234                 case ExpressionKind.UnaryOp:
235                 case ExpressionKind.True:
236                 case ExpressionKind.False:
237                 case ExpressionKind.Inc:
238                 case ExpressionKind.Dec:
239                 case ExpressionKind.LogicalNot:
240                 case ExpressionKind.Negate:
241                 case ExpressionKind.UnaryPlus:
242                 case ExpressionKind.BitwiseNot:
243                 case ExpressionKind.Addr:
244                 case ExpressionKind.DecimalNegate:
245                 case ExpressionKind.DecimalInc:
246                 case ExpressionKind.DecimalDec:
247                     exprRet = Visit((pExpr as ExprUnaryOp).Child);
248                     Debug.Assert(exprRet != null);
249                     (pExpr as ExprUnaryOp).Child = exprRet;
250                     break;
251 
252                 case ExpressionKind.UserLogicalOp:
253                     exprRet = Visit((pExpr as ExprUserLogicalOp).TrueFalseCall);
254                     Debug.Assert(exprRet != null);
255                     (pExpr as ExprUserLogicalOp).TrueFalseCall = exprRet;
256                     exprRet = Visit((pExpr as ExprUserLogicalOp).OperatorCall);
257                     Debug.Assert(exprRet != null);
258                     (pExpr as ExprUserLogicalOp).OperatorCall = exprRet as ExprCall;
259                     exprRet = Visit((pExpr as ExprUserLogicalOp).FirstOperandToExamine);
260                     Debug.Assert(exprRet != null);
261                     (pExpr as ExprUserLogicalOp).FirstOperandToExamine = exprRet;
262                     break;
263 
264                 case ExpressionKind.TypeOf:
265                     break;
266 
267                 case ExpressionKind.Cast:
268                     exprRet = Visit((pExpr as ExprCast).Argument);
269                     Debug.Assert(exprRet != null);
270                     (pExpr as ExprCast).Argument = exprRet;
271                     break;
272 
273                 case ExpressionKind.UserDefinedConversion:
274                     exprRet = Visit((pExpr as ExprUserDefinedConversion).UserDefinedCall);
275                     Debug.Assert(exprRet != null);
276                     (pExpr as ExprUserDefinedConversion).UserDefinedCall = exprRet;
277                     break;
278 
279                 case ExpressionKind.ZeroInit:
280                     break;
281 
282                 case ExpressionKind.MemberGroup:
283 
284                     // The object expression. NULL for a static invocation.
285                     exprRet = Visit((pExpr as ExprMemberGroup).OptionalObject);
286                     (pExpr as ExprMemberGroup).OptionalObject = exprRet;
287                     break;
288 
289                 case ExpressionKind.Call:
290                     exprRet = Visit((pExpr as ExprCall).OptionalArguments);
291                     (pExpr as ExprCall).OptionalArguments = exprRet;
292                     exprRet = Visit((pExpr as ExprCall).MemberGroup);
293                     Debug.Assert(exprRet != null);
294                     (pExpr as ExprCall).MemberGroup = exprRet as ExprMemberGroup;
295                     break;
296 
297                 case ExpressionKind.Property:
298                     exprRet = Visit((pExpr as ExprProperty).OptionalArguments);
299                     (pExpr as ExprProperty).OptionalArguments = exprRet;
300                     exprRet = Visit((pExpr as ExprProperty).MemberGroup);
301                     Debug.Assert(exprRet != null);
302                     (pExpr as ExprProperty).MemberGroup = exprRet as ExprMemberGroup;
303                     break;
304 
305                 case ExpressionKind.Field:
306                     exprRet = Visit((pExpr as ExprField).OptionalObject);
307                     (pExpr as ExprField).OptionalObject = exprRet;
308                     break;
309 
310                 case ExpressionKind.Constant:
311 
312                     // Used for when we zeroinit 0 parameter constructors for structs/enums.
313                     exprRet = Visit((pExpr as ExprConstant).OptionalConstructorCall);
314                     (pExpr as ExprConstant).OptionalConstructorCall = exprRet;
315                     break;
316 
317                 /*************************************************************************************************
318                   TYPEEXPRs defined:
319 
320                   The following exprs are used to represent the results of type binding, and are defined as follows:
321 
322                   TYPEARGUMENTS - This wraps the type arguments for a class. It contains the TypeArray* which is
323                     associated with the AggregateType for the instantiation of the class.
324 
325                   TYPEORNAMESPACE - This is the base class for this set of Exprs. When binding a type, the result
326                     must be a type or a namespace. This Expr encapsulates that fact. The lhs member is the Expr
327                     tree that was bound to resolve the type or namespace.
328 
329                   TYPEORNAMESPACEERROR - This is the error class for the type or namespace exprs when we don't know
330                     what to bind it to.
331 
332                   The following two exprs all have a TYPEORNAMESPACE child, which is their fundamental type:
333                     POINTERTYPE - This wraps the sym for the pointer type.
334                     NULLABLETYPE - This wraps the sym for the nullable type.
335 
336                   CLASS - This represents an instantiation of a class.
337 
338                   NSPACE - This represents a namespace, which is the intermediate step when attempting to bind
339                     a qualified name.
340 
341                   ALIAS - This represents an alias
342 
343                 *************************************************************************************************/
344 
345                 case ExpressionKind.Multi:
346                     exprRet = Visit((pExpr as ExprMulti).Left);
347                     Debug.Assert(exprRet != null);
348                     (pExpr as ExprMulti).Left = exprRet;
349                     exprRet = Visit((pExpr as ExprMulti).Operator);
350                     Debug.Assert(exprRet != null);
351                     (pExpr as ExprMulti).Operator = exprRet;
352                     break;
353 
354                 case ExpressionKind.Concat:
355                     exprRet = Visit((pExpr as ExprConcat).FirstArgument);
356                     Debug.Assert(exprRet != null);
357                     (pExpr as ExprConcat).FirstArgument = exprRet;
358                     exprRet = Visit((pExpr as ExprConcat).SecondArgument);
359                     Debug.Assert(exprRet != null);
360                     (pExpr as ExprConcat).SecondArgument = exprRet;
361                     break;
362 
363                 case ExpressionKind.ArrayInit:
364                     exprRet = Visit((pExpr as ExprArrayInit).OptionalArguments);
365                     (pExpr as ExprArrayInit).OptionalArguments = exprRet;
366                     exprRet = Visit((pExpr as ExprArrayInit).OptionalArgumentDimensions);
367                     (pExpr as ExprArrayInit).OptionalArgumentDimensions = exprRet;
368                     break;
369 
370                 case ExpressionKind.Local:
371                 case ExpressionKind.Class:
372                 case ExpressionKind.MultiGet:
373                 case ExpressionKind.Wrap:
374                 case ExpressionKind.NoOp:
375                 case ExpressionKind.FieldInfo:
376                 case ExpressionKind.MethodInfo:
377                     break;
378 
379                 default:
380                     pExpr.AssertIsBin();
381                     exprRet = Visit((pExpr as ExprBinOp).OptionalLeftChild);
382                     (pExpr as ExprBinOp).OptionalLeftChild = exprRet;
383                     exprRet = Visit((pExpr as ExprBinOp).OptionalRightChild);
384                     (pExpr as ExprBinOp).OptionalRightChild = exprRet;
385                     break;
386             }
387         }
388 
VisitEXPR(Expr pExpr)389         protected virtual Expr VisitEXPR(Expr pExpr)
390         {
391             VisitChildren(pExpr);
392             return pExpr;
393         }
VisitBINOP(ExprBinOp pExpr)394         protected virtual Expr VisitBINOP(ExprBinOp pExpr)
395         {
396             return VisitEXPR(pExpr);
397         }
VisitLIST(ExprList pExpr)398         protected virtual Expr VisitLIST(ExprList pExpr)
399         {
400             return VisitEXPR(pExpr);
401         }
VisitASSIGNMENT(ExprAssignment pExpr)402         protected virtual Expr VisitASSIGNMENT(ExprAssignment pExpr)
403         {
404             return VisitEXPR(pExpr);
405         }
406 
VisitARRAYINDEX(ExprArrayIndex pExpr)407         protected virtual Expr VisitARRAYINDEX(ExprArrayIndex pExpr)
408         {
409             return VisitEXPR(pExpr);
410         }
411 
VisitUNARYOP(ExprUnaryOp pExpr)412         protected virtual Expr VisitUNARYOP(ExprUnaryOp pExpr)
413         {
414             return VisitEXPR(pExpr);
415         }
VisitUSERLOGOP(ExprUserLogicalOp pExpr)416         protected virtual Expr VisitUSERLOGOP(ExprUserLogicalOp pExpr)
417         {
418             return VisitEXPR(pExpr);
419         }
VisitTYPEOF(ExprTypeOf pExpr)420         protected virtual Expr VisitTYPEOF(ExprTypeOf pExpr)
421         {
422             return VisitEXPR(pExpr);
423         }
VisitCAST(ExprCast pExpr)424         protected virtual Expr VisitCAST(ExprCast pExpr)
425         {
426             return VisitEXPR(pExpr);
427         }
VisitUSERDEFINEDCONVERSION(ExprUserDefinedConversion pExpr)428         protected virtual Expr VisitUSERDEFINEDCONVERSION(ExprUserDefinedConversion pExpr)
429         {
430             return VisitEXPR(pExpr);
431         }
VisitZEROINIT(ExprZeroInit pExpr)432         protected virtual Expr VisitZEROINIT(ExprZeroInit pExpr)
433         {
434             return VisitEXPR(pExpr);
435         }
VisitMEMGRP(ExprMemberGroup pExpr)436         protected virtual Expr VisitMEMGRP(ExprMemberGroup pExpr)
437         {
438             return VisitEXPR(pExpr);
439         }
VisitCALL(ExprCall pExpr)440         protected virtual Expr VisitCALL(ExprCall pExpr)
441         {
442             return VisitEXPR(pExpr);
443         }
VisitPROP(ExprProperty pExpr)444         protected virtual Expr VisitPROP(ExprProperty pExpr)
445         {
446             return VisitEXPR(pExpr);
447         }
VisitFIELD(ExprField pExpr)448         protected virtual Expr VisitFIELD(ExprField pExpr)
449         {
450             return VisitEXPR(pExpr);
451         }
VisitLOCAL(ExprLocal pExpr)452         protected virtual Expr VisitLOCAL(ExprLocal pExpr)
453         {
454             return VisitEXPR(pExpr);
455         }
VisitCONSTANT(ExprConstant pExpr)456         protected virtual Expr VisitCONSTANT(ExprConstant pExpr)
457         {
458             return VisitEXPR(pExpr);
459         }
VisitMULTIGET(ExprMultiGet pExpr)460         protected virtual Expr VisitMULTIGET(ExprMultiGet pExpr)
461         {
462             return VisitEXPR(pExpr);
463         }
VisitMULTI(ExprMulti pExpr)464         protected virtual Expr VisitMULTI(ExprMulti pExpr)
465         {
466             return VisitEXPR(pExpr);
467         }
VisitWRAP(ExprWrap pExpr)468         protected virtual Expr VisitWRAP(ExprWrap pExpr)
469         {
470             return VisitEXPR(pExpr);
471         }
VisitCONCAT(ExprConcat pExpr)472         protected virtual Expr VisitCONCAT(ExprConcat pExpr)
473         {
474             return VisitEXPR(pExpr);
475         }
VisitARRINIT(ExprArrayInit pExpr)476         protected virtual Expr VisitARRINIT(ExprArrayInit pExpr)
477         {
478             return VisitEXPR(pExpr);
479         }
480 
VisitFIELDINFO(ExprFieldInfo pExpr)481         protected virtual Expr VisitFIELDINFO(ExprFieldInfo pExpr)
482         {
483             return VisitEXPR(pExpr);
484         }
VisitMETHODINFO(ExprMethodInfo pExpr)485         protected virtual Expr VisitMETHODINFO(ExprMethodInfo pExpr)
486         {
487             return VisitEXPR(pExpr);
488         }
VisitEQUALS(ExprBinOp pExpr)489         protected virtual Expr VisitEQUALS(ExprBinOp pExpr)
490         {
491             return VisitBINOP(pExpr);
492         }
VisitCOMPARE(ExprBinOp pExpr)493         protected virtual Expr VisitCOMPARE(ExprBinOp pExpr)
494         {
495             return VisitBINOP(pExpr);
496         }
VisitEQ(ExprBinOp pExpr)497         protected virtual Expr VisitEQ(ExprBinOp pExpr)
498         {
499             return VisitBINOP(pExpr);
500         }
VisitNE(ExprBinOp pExpr)501         protected virtual Expr VisitNE(ExprBinOp pExpr)
502         {
503             return VisitBINOP(pExpr);
504         }
VisitLE(ExprBinOp pExpr)505         protected virtual Expr VisitLE(ExprBinOp pExpr)
506         {
507             return VisitBINOP(pExpr);
508         }
VisitGE(ExprBinOp pExpr)509         protected virtual Expr VisitGE(ExprBinOp pExpr)
510         {
511             return VisitBINOP(pExpr);
512         }
VisitADD(ExprBinOp pExpr)513         protected virtual Expr VisitADD(ExprBinOp pExpr)
514         {
515             return VisitBINOP(pExpr);
516         }
VisitSUB(ExprBinOp pExpr)517         protected virtual Expr VisitSUB(ExprBinOp pExpr)
518         {
519             return VisitBINOP(pExpr);
520         }
VisitDIV(ExprBinOp pExpr)521         protected virtual Expr VisitDIV(ExprBinOp pExpr)
522         {
523             return VisitBINOP(pExpr);
524         }
VisitBITAND(ExprBinOp pExpr)525         protected virtual Expr VisitBITAND(ExprBinOp pExpr)
526         {
527             return VisitBINOP(pExpr);
528         }
VisitBITOR(ExprBinOp pExpr)529         protected virtual Expr VisitBITOR(ExprBinOp pExpr)
530         {
531             return VisitBINOP(pExpr);
532         }
VisitLSHIFT(ExprBinOp pExpr)533         protected virtual Expr VisitLSHIFT(ExprBinOp pExpr)
534         {
535             return VisitBINOP(pExpr);
536         }
VisitLOGAND(ExprBinOp pExpr)537         protected virtual Expr VisitLOGAND(ExprBinOp pExpr)
538         {
539             return VisitBINOP(pExpr);
540         }
VisitSEQUENCE(ExprBinOp pExpr)541         protected virtual Expr VisitSEQUENCE(ExprBinOp pExpr)
542         {
543             return VisitBINOP(pExpr);
544         }
VisitSAVE(ExprBinOp pExpr)545         protected virtual Expr VisitSAVE(ExprBinOp pExpr)
546         {
547             return VisitBINOP(pExpr);
548         }
VisitINDIR(ExprBinOp pExpr)549         protected virtual Expr VisitINDIR(ExprBinOp pExpr)
550         {
551             return VisitBINOP(pExpr);
552         }
VisitSTRINGEQ(ExprBinOp pExpr)553         protected virtual Expr VisitSTRINGEQ(ExprBinOp pExpr)
554         {
555             return VisitBINOP(pExpr);
556         }
VisitDELEGATEEQ(ExprBinOp pExpr)557         protected virtual Expr VisitDELEGATEEQ(ExprBinOp pExpr)
558         {
559             return VisitBINOP(pExpr);
560         }
VisitDELEGATEADD(ExprBinOp pExpr)561         protected virtual Expr VisitDELEGATEADD(ExprBinOp pExpr)
562         {
563             return VisitBINOP(pExpr);
564         }
565 
VisitLT(ExprBinOp pExpr)566         protected virtual Expr VisitLT(ExprBinOp pExpr)
567         {
568             return VisitBINOP(pExpr);
569         }
VisitMUL(ExprBinOp pExpr)570         protected virtual Expr VisitMUL(ExprBinOp pExpr)
571         {
572             return VisitBINOP(pExpr);
573         }
VisitBITXOR(ExprBinOp pExpr)574         protected virtual Expr VisitBITXOR(ExprBinOp pExpr)
575         {
576             return VisitBINOP(pExpr);
577         }
VisitRSHIFT(ExprBinOp pExpr)578         protected virtual Expr VisitRSHIFT(ExprBinOp pExpr)
579         {
580             return VisitBINOP(pExpr);
581         }
VisitLOGOR(ExprBinOp pExpr)582         protected virtual Expr VisitLOGOR(ExprBinOp pExpr)
583         {
584             return VisitBINOP(pExpr);
585         }
VisitSTRINGNE(ExprBinOp pExpr)586         protected virtual Expr VisitSTRINGNE(ExprBinOp pExpr)
587         {
588             return VisitBINOP(pExpr);
589         }
VisitDELEGATENE(ExprBinOp pExpr)590         protected virtual Expr VisitDELEGATENE(ExprBinOp pExpr)
591         {
592             return VisitBINOP(pExpr);
593         }
VisitGT(ExprBinOp pExpr)594         protected virtual Expr VisitGT(ExprBinOp pExpr)
595         {
596             return VisitBINOP(pExpr);
597         }
VisitMOD(ExprBinOp pExpr)598         protected virtual Expr VisitMOD(ExprBinOp pExpr)
599         {
600             return VisitBINOP(pExpr);
601         }
VisitSWAP(ExprBinOp pExpr)602         protected virtual Expr VisitSWAP(ExprBinOp pExpr)
603         {
604             return VisitBINOP(pExpr);
605         }
VisitDELEGATESUB(ExprBinOp pExpr)606         protected virtual Expr VisitDELEGATESUB(ExprBinOp pExpr)
607         {
608             return VisitBINOP(pExpr);
609         }
VisitTRUE(ExprUnaryOp pExpr)610         protected virtual Expr VisitTRUE(ExprUnaryOp pExpr)
611         {
612             return VisitUNARYOP(pExpr);
613         }
VisitINC(ExprUnaryOp pExpr)614         protected virtual Expr VisitINC(ExprUnaryOp pExpr)
615         {
616             return VisitUNARYOP(pExpr);
617         }
VisitLOGNOT(ExprUnaryOp pExpr)618         protected virtual Expr VisitLOGNOT(ExprUnaryOp pExpr)
619         {
620             return VisitUNARYOP(pExpr);
621         }
VisitNEG(ExprUnaryOp pExpr)622         protected virtual Expr VisitNEG(ExprUnaryOp pExpr)
623         {
624             return VisitUNARYOP(pExpr);
625         }
VisitBITNOT(ExprUnaryOp pExpr)626         protected virtual Expr VisitBITNOT(ExprUnaryOp pExpr)
627         {
628             return VisitUNARYOP(pExpr);
629         }
VisitADDR(ExprUnaryOp pExpr)630         protected virtual Expr VisitADDR(ExprUnaryOp pExpr)
631         {
632             return VisitUNARYOP(pExpr);
633         }
VisitDECIMALNEG(ExprUnaryOp pExpr)634         protected virtual Expr VisitDECIMALNEG(ExprUnaryOp pExpr)
635         {
636             return VisitUNARYOP(pExpr);
637         }
VisitDECIMALDEC(ExprUnaryOp pExpr)638         protected virtual Expr VisitDECIMALDEC(ExprUnaryOp pExpr)
639         {
640             return VisitUNARYOP(pExpr);
641         }
VisitFALSE(ExprUnaryOp pExpr)642         protected virtual Expr VisitFALSE(ExprUnaryOp pExpr)
643         {
644             return VisitUNARYOP(pExpr);
645         }
VisitDEC(ExprUnaryOp pExpr)646         protected virtual Expr VisitDEC(ExprUnaryOp pExpr)
647         {
648             return VisitUNARYOP(pExpr);
649         }
VisitUPLUS(ExprUnaryOp pExpr)650         protected virtual Expr VisitUPLUS(ExprUnaryOp pExpr)
651         {
652             return VisitUNARYOP(pExpr);
653         }
VisitDECIMALINC(ExprUnaryOp pExpr)654         protected virtual Expr VisitDECIMALINC(ExprUnaryOp pExpr)
655         {
656             return VisitUNARYOP(pExpr);
657         }
658     }
659 }
660