← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to contrib/ICSharpCode.NRefactory.CSharp/Ast/ObservableAstVisitor.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
ImportĀ upstreamĀ versionĀ 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ICSharpCode.NRefactory.CSharp/Ast/ObservableAstVisitor.cs
1
 
ļ»æ// 
2
 
// ObservableAstVisitor.cs
3
 
//  
4
 
// Author:
5
 
//       Mike KrĆ¼ger <mkrueger@novell.com>
6
 
// 
7
 
// Copyright (c) 2011 Novell, Inc (http://www.novell.com)
8
 
// 
9
 
// Permission is hereby granted, free of charge, to any person obtaining a copy
10
 
// of this software and associated documentation files (the "Software"), to deal
11
 
// in the Software without restriction, including without limitation the rights
12
 
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13
 
// copies of the Software, and to permit persons to whom the Software is
14
 
// furnished to do so, subject to the following conditions:
15
 
// 
16
 
// The above copyright notice and this permission notice shall be included in
17
 
// all copies or substantial portions of the Software.
18
 
// 
19
 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20
 
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21
 
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22
 
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23
 
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24
 
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25
 
// THE SOFTWARE.
26
 
using System;
27
 
 
28
 
namespace ICSharpCode.NRefactory.CSharp
29
 
{
30
 
        public class ObservableAstVisitor<T, S>: IAstVisitor<T, S>
31
 
        {
32
 
                S VisitChildren (AstNode node, T data)
33
 
                {
34
 
                        AstNode next;
35
 
                        for (var child = node.FirstChild; child != null; child = next) {
36
 
                                // Store next to allow the loop to continue
37
 
                                // if the visitor removes/replaces child.
38
 
                                next = child.NextSibling;
39
 
                                child.AcceptVisitor (this, data);
40
 
                        }
41
 
                        return default (S);
42
 
                }
43
 
                
44
 
                public event Action<CompilationUnit, T> CompilationUnitVisited;
45
 
 
46
 
                S IAstVisitor<T, S>.VisitCompilationUnit (CompilationUnit unit, T data)
47
 
                {
48
 
                        var handler = CompilationUnitVisited;
49
 
                        if (handler != null)
50
 
                                handler (unit, data);
51
 
                        return VisitChildren (unit, data);
52
 
                }
53
 
                
54
 
                public event Action<Comment, T> CommentVisited;
55
 
 
56
 
                S IAstVisitor<T, S>.VisitComment (Comment comment, T data)
57
 
                {
58
 
                        var handler = CommentVisited;
59
 
                        if (handler != null)
60
 
                                handler (comment, data);
61
 
                        return VisitChildren (comment, data);
62
 
                }
63
 
 
64
 
                public event Action<NewLineNode, T> NewLineVisited;
65
 
 
66
 
                S IAstVisitor<T, S>.VisitNewLine(NewLineNode newLineNode, T data)
67
 
                {
68
 
                        var handler = NewLineVisited;
69
 
                        if (handler != null)
70
 
                                handler(newLineNode, data);
71
 
                        return VisitChildren(newLineNode, data);
72
 
                }
73
 
 
74
 
                public event Action<WhitespaceNode, T> WhitespaceVisited;
75
 
 
76
 
                S IAstVisitor<T, S>.VisitWhitespace(WhitespaceNode whitespace, T data)
77
 
                {
78
 
                        var handler = WhitespaceVisited;
79
 
                        if (handler != null)
80
 
                                handler(whitespace, data);
81
 
                        return VisitChildren(whitespace, data);
82
 
                }
83
 
 
84
 
                public event Action<TextNode, T> TextVisited;
85
 
 
86
 
                S IAstVisitor<T, S>.VisitText(TextNode textNode, T data)
87
 
                {
88
 
                        var handler = TextVisited;
89
 
                        if (handler != null)
90
 
                                handler(textNode, data);
91
 
                        return VisitChildren(textNode, data);
92
 
                }
93
 
 
94
 
                public event Action<PreProcessorDirective, T> PreProcessorDirectiveVisited;
95
 
                S IAstVisitor<T, S>.VisitPreProcessorDirective (PreProcessorDirective preProcessorDirective, T data)
96
 
                {
97
 
                        var handler = PreProcessorDirectiveVisited;
98
 
                        if (handler != null)
99
 
                                handler (preProcessorDirective, data);
100
 
                        return VisitChildren (preProcessorDirective, data);
101
 
                }
102
 
                
103
 
                public event Action<DocumentationReference, T> DocumentationReferenceVisited;
104
 
 
105
 
                S IAstVisitor<T, S>.VisitDocumentationReference (DocumentationReference documentationReference, T data)
106
 
                {
107
 
                        var handler = DocumentationReferenceVisited;
108
 
                        if (handler != null)
109
 
                                handler (documentationReference, data);
110
 
                        return VisitChildren (documentationReference, data);
111
 
                }
112
 
                
113
 
                public event Action<Identifier, T> IdentifierVisited;
114
 
 
115
 
                S IAstVisitor<T, S>.VisitIdentifier (Identifier identifier, T data)
116
 
                {
117
 
                        var handler = IdentifierVisited;
118
 
                        if (handler != null)
119
 
                                handler (identifier, data);
120
 
                        return VisitChildren (identifier, data);
121
 
                }
122
 
                
123
 
                public event Action<CSharpTokenNode, T> CSharpTokenNodeVisited;
124
 
 
125
 
                S IAstVisitor<T, S>.VisitCSharpTokenNode (CSharpTokenNode token, T data)
126
 
                {
127
 
                        var handler = CSharpTokenNodeVisited;
128
 
                        if (handler != null)
129
 
                                handler (token, data);
130
 
                        return VisitChildren (token, data);
131
 
                }
132
 
                
133
 
                public event Action<PrimitiveType, T> PrimitiveTypeVisited;
134
 
 
135
 
                S IAstVisitor<T, S>.VisitPrimitiveType (PrimitiveType primitiveType, T data)
136
 
                {
137
 
                        var handler = PrimitiveTypeVisited;
138
 
                        if (handler != null)
139
 
                                handler (primitiveType, data);
140
 
                        return VisitChildren (primitiveType, data);
141
 
                }
142
 
                
143
 
                public event Action<ComposedType, T> ComposedTypeVisited;
144
 
 
145
 
                S IAstVisitor<T, S>.VisitComposedType (ComposedType composedType, T data)
146
 
                {
147
 
                        var handler = ComposedTypeVisited;
148
 
                        if (handler != null)
149
 
                                handler (composedType, data);
150
 
                        return VisitChildren (composedType, data);
151
 
                }
152
 
                
153
 
                public event Action<SimpleType, T> SimpleTypeVisited;
154
 
 
155
 
                S IAstVisitor<T, S>.VisitSimpleType (SimpleType simpleType, T data)
156
 
                {
157
 
                        var handler = SimpleTypeVisited;
158
 
                        if (handler != null)
159
 
                                handler (simpleType, data);
160
 
                        return VisitChildren (simpleType, data);
161
 
                }
162
 
                
163
 
                public event Action<MemberType, T> MemberTypeVisited;
164
 
 
165
 
                S IAstVisitor<T, S>.VisitMemberType (MemberType memberType, T data)
166
 
                {
167
 
                        var handler = MemberTypeVisited;
168
 
                        if (handler != null)
169
 
                                handler (memberType, data);
170
 
                        return VisitChildren (memberType, data);
171
 
                }
172
 
                
173
 
                public event Action<Attribute, T> AttributeVisited;
174
 
 
175
 
                S IAstVisitor<T, S>.VisitAttribute (Attribute attribute, T data)
176
 
                {
177
 
                        var handler = AttributeVisited;
178
 
                        if (handler != null)
179
 
                                handler (attribute, data);
180
 
                        return VisitChildren (attribute, data);
181
 
                }
182
 
                
183
 
                public event Action<AttributeSection, T> AttributeSectionVisited;
184
 
 
185
 
                S IAstVisitor<T, S>.VisitAttributeSection (AttributeSection attributeSection, T data)
186
 
                {
187
 
                        var handler = AttributeSectionVisited;
188
 
                        if (handler != null)
189
 
                                handler (attributeSection, data);
190
 
                        return VisitChildren (attributeSection, data);
191
 
                }
192
 
                
193
 
                public event Action<DelegateDeclaration, T> DelegateDeclarationVisited;
194
 
 
195
 
                S IAstVisitor<T, S>.VisitDelegateDeclaration (DelegateDeclaration delegateDeclaration, T data)
196
 
                {
197
 
                        var handler = DelegateDeclarationVisited;
198
 
                        if (handler != null)
199
 
                                handler (delegateDeclaration, data);
200
 
                        return VisitChildren (delegateDeclaration, data);
201
 
                }
202
 
                
203
 
                public event Action<NamespaceDeclaration, T> NamespaceDeclarationVisited;
204
 
 
205
 
                S IAstVisitor<T, S>.VisitNamespaceDeclaration (NamespaceDeclaration namespaceDeclaration, T data)
206
 
                {
207
 
                        var handler = NamespaceDeclarationVisited;
208
 
                        if (handler != null)
209
 
                                handler (namespaceDeclaration, data);
210
 
                        return VisitChildren (namespaceDeclaration, data);
211
 
                }
212
 
                
213
 
                public event Action<TypeDeclaration, T> TypeDeclarationVisited;
214
 
 
215
 
                S IAstVisitor<T, S>.VisitTypeDeclaration (TypeDeclaration typeDeclaration, T data)
216
 
                {
217
 
                        var handler = TypeDeclarationVisited;
218
 
                        if (handler != null)
219
 
                                handler (typeDeclaration, data);
220
 
                        return VisitChildren (typeDeclaration, data);
221
 
                }
222
 
                
223
 
                public event Action<TypeParameterDeclaration, T> TypeParameterDeclarationVisited;
224
 
 
225
 
                S IAstVisitor<T, S>.VisitTypeParameterDeclaration (TypeParameterDeclaration typeParameterDeclaration, T data)
226
 
                {
227
 
                        var handler = TypeParameterDeclarationVisited;
228
 
                        if (handler != null)
229
 
                                handler (typeParameterDeclaration, data);
230
 
                        return VisitChildren (typeParameterDeclaration, data);
231
 
                }
232
 
                
233
 
                public event Action<EnumMemberDeclaration, T> EnumMemberDeclarationVisited;
234
 
 
235
 
                S IAstVisitor<T, S>.VisitEnumMemberDeclaration (EnumMemberDeclaration enumMemberDeclaration, T data)
236
 
                {
237
 
                        var handler = EnumMemberDeclarationVisited;
238
 
                        if (handler != null)
239
 
                                handler (enumMemberDeclaration, data);
240
 
                        return VisitChildren (enumMemberDeclaration, data);
241
 
                }
242
 
                
243
 
                public event Action<UsingDeclaration, T> UsingDeclarationVisited;
244
 
 
245
 
                S IAstVisitor<T, S>.VisitUsingDeclaration (UsingDeclaration usingDeclaration, T data)
246
 
                {
247
 
                        var handler = UsingDeclarationVisited;
248
 
                        if (handler != null)
249
 
                                handler (usingDeclaration, data);
250
 
                        return VisitChildren (usingDeclaration, data);
251
 
                }
252
 
                
253
 
                public event Action<UsingAliasDeclaration, T> UsingAliasDeclarationVisited;
254
 
 
255
 
                S IAstVisitor<T, S>.VisitUsingAliasDeclaration (UsingAliasDeclaration usingDeclaration, T data)
256
 
                {
257
 
                        var handler = UsingAliasDeclarationVisited;
258
 
                        if (handler != null)
259
 
                                handler (usingDeclaration, data);
260
 
                        return VisitChildren (usingDeclaration, data);
261
 
                }
262
 
                
263
 
                public event Action<ExternAliasDeclaration, T> ExternAliasDeclarationVisited;
264
 
 
265
 
                S IAstVisitor<T, S>.VisitExternAliasDeclaration (ExternAliasDeclaration externAliasDeclaration, T data)
266
 
                {
267
 
                        var handler = ExternAliasDeclarationVisited;
268
 
                        if (handler != null)
269
 
                                handler (externAliasDeclaration, data);
270
 
                        return VisitChildren (externAliasDeclaration, data);
271
 
                }
272
 
                
273
 
                public event Action<ConstructorDeclaration, T> ConstructorDeclarationVisited;
274
 
 
275
 
                S IAstVisitor<T, S>.VisitConstructorDeclaration (ConstructorDeclaration constructorDeclaration, T data)
276
 
                {
277
 
                        var handler = ConstructorDeclarationVisited;
278
 
                        if (handler != null)
279
 
                                handler (constructorDeclaration, data);
280
 
                        return VisitChildren (constructorDeclaration, data);
281
 
                }
282
 
                
283
 
                public event Action<ConstructorInitializer, T> ConstructorInitializerVisited;
284
 
 
285
 
                S IAstVisitor<T, S>.VisitConstructorInitializer (ConstructorInitializer constructorInitializer, T data)
286
 
                {
287
 
                        var handler = ConstructorInitializerVisited;
288
 
                        if (handler != null)
289
 
                                handler (constructorInitializer, data);
290
 
                        return VisitChildren (constructorInitializer, data);
291
 
                }
292
 
                
293
 
                public event Action<DestructorDeclaration, T> DestructorDeclarationVisited;
294
 
 
295
 
                S IAstVisitor<T, S>.VisitDestructorDeclaration (DestructorDeclaration destructorDeclaration, T data)
296
 
                {
297
 
                        var handler = DestructorDeclarationVisited;
298
 
                        if (handler != null)
299
 
                                handler (destructorDeclaration, data);
300
 
                        return VisitChildren (destructorDeclaration, data);
301
 
                }
302
 
                
303
 
                public event Action<EventDeclaration, T> EventDeclarationVisited;
304
 
 
305
 
                S IAstVisitor<T, S>.VisitEventDeclaration (EventDeclaration eventDeclaration, T data)
306
 
                {
307
 
                        var handler = EventDeclarationVisited;
308
 
                        if (handler != null)
309
 
                                handler (eventDeclaration, data);
310
 
                        return VisitChildren (eventDeclaration, data);
311
 
                }
312
 
                
313
 
                public event Action<CustomEventDeclaration, T> CustomEventDeclarationVisited;
314
 
 
315
 
                S IAstVisitor<T, S>.VisitCustomEventDeclaration (CustomEventDeclaration eventDeclaration, T data)
316
 
                {
317
 
                        var handler = CustomEventDeclarationVisited;
318
 
                        if (handler != null)
319
 
                                handler (eventDeclaration, data);
320
 
                        return VisitChildren (eventDeclaration, data);
321
 
                }
322
 
                
323
 
                public event Action<FieldDeclaration, T> FieldDeclarationVisited;
324
 
 
325
 
                S IAstVisitor<T, S>.VisitFieldDeclaration (FieldDeclaration fieldDeclaration, T data)
326
 
                {
327
 
                        var handler = FieldDeclarationVisited;
328
 
                        if (handler != null)
329
 
                                handler (fieldDeclaration, data);
330
 
                        return VisitChildren (fieldDeclaration, data);
331
 
                }
332
 
                
333
 
                public event Action<FixedFieldDeclaration, T> FixedFieldDeclarationVisited;
334
 
 
335
 
                S IAstVisitor<T, S>.VisitFixedFieldDeclaration (FixedFieldDeclaration fixedFieldDeclaration, T data)
336
 
                {
337
 
                        var handler = FixedFieldDeclarationVisited;
338
 
                        if (handler != null)
339
 
                                handler (fixedFieldDeclaration, data);
340
 
                        return VisitChildren (fixedFieldDeclaration, data);
341
 
                }
342
 
                
343
 
                public event Action<FixedVariableInitializer, T> FixedVariableInitializerVisited;
344
 
 
345
 
                S IAstVisitor<T, S>.VisitFixedVariableInitializer (FixedVariableInitializer fixedVariableInitializer, T data)
346
 
                {
347
 
                        var handler = FixedVariableInitializerVisited;
348
 
                        if (handler != null)
349
 
                                handler (fixedVariableInitializer, data);
350
 
                        return VisitChildren (fixedVariableInitializer, data);
351
 
                }
352
 
                
353
 
                public event Action<IndexerDeclaration, T> IndexerDeclarationVisited;
354
 
 
355
 
                S IAstVisitor<T, S>.VisitIndexerDeclaration (IndexerDeclaration indexerDeclaration, T data)
356
 
                {
357
 
                        var handler = IndexerDeclarationVisited;
358
 
                        if (handler != null)
359
 
                                handler (indexerDeclaration, data);
360
 
                        return VisitChildren (indexerDeclaration, data);
361
 
                }
362
 
                
363
 
                public event Action<MethodDeclaration, T> MethodDeclarationVisited;
364
 
 
365
 
                S IAstVisitor<T, S>.VisitMethodDeclaration (MethodDeclaration methodDeclaration, T data)
366
 
                {
367
 
                        var handler = MethodDeclarationVisited;
368
 
                        if (handler != null)
369
 
                                handler (methodDeclaration, data);
370
 
                        return VisitChildren (methodDeclaration, data);
371
 
                }
372
 
                
373
 
                public event Action<OperatorDeclaration, T> OperatorDeclarationVisited;
374
 
 
375
 
                S IAstVisitor<T, S>.VisitOperatorDeclaration (OperatorDeclaration operatorDeclaration, T data)
376
 
                {
377
 
                        var handler = OperatorDeclarationVisited;
378
 
                        if (handler != null)
379
 
                                handler (operatorDeclaration, data);
380
 
                        return VisitChildren (operatorDeclaration, data);
381
 
                }
382
 
                
383
 
                public event Action<PropertyDeclaration, T> PropertyDeclarationVisited;
384
 
 
385
 
                S IAstVisitor<T, S>.VisitPropertyDeclaration (PropertyDeclaration propertyDeclaration, T data)
386
 
                {
387
 
                        var handler = PropertyDeclarationVisited;
388
 
                        if (handler != null)
389
 
                                handler (propertyDeclaration, data);
390
 
                        return VisitChildren (propertyDeclaration, data);
391
 
                }
392
 
                
393
 
                public event Action<Accessor, T> AccessorVisited;
394
 
 
395
 
                S IAstVisitor<T, S>.VisitAccessor (Accessor accessor, T data)
396
 
                {
397
 
                        var handler = AccessorVisited;
398
 
                        if (handler != null)
399
 
                                handler (accessor, data);
400
 
                        return VisitChildren (accessor, data);
401
 
                }
402
 
                
403
 
                public event Action<VariableInitializer, T> VariableInitializerVisited;
404
 
 
405
 
                S IAstVisitor<T, S>.VisitVariableInitializer (VariableInitializer variableInitializer, T data)
406
 
                {
407
 
                        var handler = VariableInitializerVisited;
408
 
                        if (handler != null)
409
 
                                handler (variableInitializer, data);
410
 
                        return VisitChildren (variableInitializer, data);
411
 
                }
412
 
                
413
 
                public event Action<ParameterDeclaration, T> ParameterDeclarationVisited;
414
 
 
415
 
                S IAstVisitor<T, S>.VisitParameterDeclaration (ParameterDeclaration parameterDeclaration, T data)
416
 
                {
417
 
                        var handler = ParameterDeclarationVisited;
418
 
                        if (handler != null)
419
 
                                handler (parameterDeclaration, data);
420
 
                        return VisitChildren (parameterDeclaration, data);
421
 
                }
422
 
                
423
 
                public event Action<Constraint, T> ConstraintVisited;
424
 
 
425
 
                S IAstVisitor<T, S>.VisitConstraint (Constraint constraint, T data)
426
 
                {
427
 
                        var handler = ConstraintVisited;
428
 
                        if (handler != null)
429
 
                                handler (constraint, data);
430
 
                        return VisitChildren (constraint, data);
431
 
                }
432
 
                
433
 
                public event Action<BlockStatement, T> BlockStatementVisited;
434
 
 
435
 
                S IAstVisitor<T, S>.VisitBlockStatement (BlockStatement blockStatement, T data)
436
 
                {
437
 
                        var handler = BlockStatementVisited;
438
 
                        if (handler != null)
439
 
                                handler (blockStatement, data);
440
 
                        return VisitChildren (blockStatement, data);
441
 
                }
442
 
                
443
 
                public event Action<ExpressionStatement, T> ExpressionStatementVisited;
444
 
 
445
 
                S IAstVisitor<T, S>.VisitExpressionStatement (ExpressionStatement expressionStatement, T data)
446
 
                {
447
 
                        var handler = ExpressionStatementVisited;
448
 
                        if (handler != null)
449
 
                                handler (expressionStatement, data);
450
 
                        return VisitChildren (expressionStatement, data);
451
 
                }
452
 
                
453
 
                public event Action<BreakStatement, T> BreakStatementVisited;
454
 
 
455
 
                S IAstVisitor<T, S>.VisitBreakStatement (BreakStatement breakStatement, T data)
456
 
                {
457
 
                        var handler = BreakStatementVisited;
458
 
                        if (handler != null)
459
 
                                handler (breakStatement, data);
460
 
                        return VisitChildren (breakStatement, data);
461
 
                }
462
 
                
463
 
                public event Action<CheckedStatement, T> CheckedStatementVisited;
464
 
 
465
 
                S IAstVisitor<T, S>.VisitCheckedStatement (CheckedStatement checkedStatement, T data)
466
 
                {
467
 
                        var handler = CheckedStatementVisited;
468
 
                        if (handler != null)
469
 
                                handler (checkedStatement, data);
470
 
                        return VisitChildren (checkedStatement, data);
471
 
                }
472
 
                
473
 
                public event Action<ContinueStatement, T> ContinueStatementVisited;
474
 
 
475
 
                S IAstVisitor<T, S>.VisitContinueStatement (ContinueStatement continueStatement, T data)
476
 
                {
477
 
                        var handler = ContinueStatementVisited;
478
 
                        if (handler != null)
479
 
                                handler (continueStatement, data);
480
 
                        return VisitChildren (continueStatement, data);
481
 
                }
482
 
                
483
 
                public event Action<DoWhileStatement, T> DoWhileStatementVisited;
484
 
 
485
 
                S IAstVisitor<T, S>.VisitDoWhileStatement (DoWhileStatement doWhileStatement, T data)
486
 
                {
487
 
                        var handler = DoWhileStatementVisited;
488
 
                        if (handler != null)
489
 
                                handler (doWhileStatement, data);
490
 
                        return VisitChildren (doWhileStatement, data);
491
 
                }
492
 
                
493
 
                public event Action<EmptyStatement, T> EmptyStatementVisited;
494
 
 
495
 
                S IAstVisitor<T, S>.VisitEmptyStatement (EmptyStatement emptyStatement, T data)
496
 
                {
497
 
                        var handler = EmptyStatementVisited;
498
 
                        if (handler != null)
499
 
                                handler (emptyStatement, data);
500
 
                        return VisitChildren (emptyStatement, data);
501
 
                }
502
 
                
503
 
                public event Action<FixedStatement, T> FixedStatementVisited;
504
 
 
505
 
                S IAstVisitor<T, S>.VisitFixedStatement (FixedStatement fixedStatement, T data)
506
 
                {
507
 
                        var handler = FixedStatementVisited;
508
 
                        if (handler != null)
509
 
                                handler (fixedStatement, data);
510
 
                        return VisitChildren (fixedStatement, data);
511
 
                }
512
 
                
513
 
                public event Action<ForeachStatement, T> ForeachStatementVisited;
514
 
 
515
 
                S IAstVisitor<T, S>.VisitForeachStatement (ForeachStatement foreachStatement, T data)
516
 
                {
517
 
                        var handler = ForeachStatementVisited;
518
 
                        if (handler != null)
519
 
                                handler (foreachStatement, data);
520
 
                        return VisitChildren (foreachStatement, data);
521
 
                }
522
 
                
523
 
                public event Action<ForStatement, T> ForStatementVisited;
524
 
 
525
 
                S IAstVisitor<T, S>.VisitForStatement (ForStatement forStatement, T data)
526
 
                {
527
 
                        var handler = ForStatementVisited;
528
 
                        if (handler != null)
529
 
                                handler (forStatement, data);
530
 
                        return VisitChildren (forStatement, data);
531
 
                }
532
 
                
533
 
                public event Action<GotoCaseStatement, T> GotoCaseStatementVisited;
534
 
 
535
 
                S IAstVisitor<T, S>.VisitGotoCaseStatement (GotoCaseStatement gotoCaseStatement, T data)
536
 
                {
537
 
                        var handler = GotoCaseStatementVisited;
538
 
                        if (handler != null)
539
 
                                handler (gotoCaseStatement, data);
540
 
                        return VisitChildren (gotoCaseStatement, data);
541
 
                }
542
 
                
543
 
                public event Action<GotoDefaultStatement, T> GotoDefaultStatementVisited;
544
 
 
545
 
                S IAstVisitor<T, S>.VisitGotoDefaultStatement (GotoDefaultStatement gotoDefaultStatement, T data)
546
 
                {
547
 
                        var handler = GotoDefaultStatementVisited;
548
 
                        if (handler != null)
549
 
                                handler (gotoDefaultStatement, data);
550
 
                        return VisitChildren (gotoDefaultStatement, data);
551
 
                }
552
 
                
553
 
                public event Action<GotoStatement, T> GotoStatementVisited;
554
 
 
555
 
                S IAstVisitor<T, S>.VisitGotoStatement (GotoStatement gotoStatement, T data)
556
 
                {
557
 
                        var handler = GotoStatementVisited;
558
 
                        if (handler != null)
559
 
                                handler (gotoStatement, data);
560
 
                        return VisitChildren (gotoStatement, data);
561
 
                }
562
 
                
563
 
                public event Action<IfElseStatement, T> IfElseStatementVisited;
564
 
 
565
 
                S IAstVisitor<T, S>.VisitIfElseStatement (IfElseStatement ifElseStatement, T data)
566
 
                {
567
 
                        var handler = IfElseStatementVisited;
568
 
                        if (handler != null)
569
 
                                handler (ifElseStatement, data);
570
 
                        return VisitChildren (ifElseStatement, data);
571
 
                }
572
 
                
573
 
                public event Action<LabelStatement, T> LabelStatementVisited;
574
 
 
575
 
                S IAstVisitor<T, S>.VisitLabelStatement (LabelStatement labelStatement, T data)
576
 
                {
577
 
                        var handler = LabelStatementVisited;
578
 
                        if (handler != null)
579
 
                                handler (labelStatement, data);
580
 
                        return VisitChildren (labelStatement, data);
581
 
                }
582
 
                
583
 
                public event Action<LockStatement, T> LockStatementVisited;
584
 
 
585
 
                S IAstVisitor<T, S>.VisitLockStatement (LockStatement lockStatement, T data)
586
 
                {
587
 
                        var handler = LockStatementVisited;
588
 
                        if (handler != null)
589
 
                                handler (lockStatement, data);
590
 
                        return VisitChildren (lockStatement, data);
591
 
                }
592
 
                
593
 
                public event Action<ReturnStatement, T> ReturnStatementVisited;
594
 
 
595
 
                S IAstVisitor<T, S>.VisitReturnStatement (ReturnStatement returnStatement, T data)
596
 
                {
597
 
                        var handler = ReturnStatementVisited;
598
 
                        if (handler != null)
599
 
                                handler (returnStatement, data);
600
 
                        return VisitChildren (returnStatement, data);
601
 
                }
602
 
                
603
 
                public event Action<SwitchStatement, T> SwitchStatementVisited;
604
 
 
605
 
                S IAstVisitor<T, S>.VisitSwitchStatement (SwitchStatement switchStatement, T data)
606
 
                {
607
 
                        var handler = SwitchStatementVisited;
608
 
                        if (handler != null)
609
 
                                handler (switchStatement, data);
610
 
                        return VisitChildren (switchStatement, data);
611
 
                }
612
 
                
613
 
                public event Action<SwitchSection, T> SwitchSectionVisited;
614
 
 
615
 
                S IAstVisitor<T, S>.VisitSwitchSection (SwitchSection switchSection, T data)
616
 
                {
617
 
                        var handler = SwitchSectionVisited;
618
 
                        if (handler != null)
619
 
                                handler (switchSection, data);
620
 
                        return VisitChildren (switchSection, data);
621
 
                }
622
 
                
623
 
                public event Action<CaseLabel, T> CaseLabelVisited;
624
 
 
625
 
                S IAstVisitor<T, S>.VisitCaseLabel (CaseLabel caseLabel, T data)
626
 
                {
627
 
                        var handler = CaseLabelVisited;
628
 
                        if (handler != null)
629
 
                                handler (caseLabel, data);
630
 
                        return VisitChildren (caseLabel, data);
631
 
                }
632
 
                
633
 
                public event Action<ThrowStatement, T> ThrowStatementVisited;
634
 
 
635
 
                S IAstVisitor<T, S>.VisitThrowStatement (ThrowStatement throwStatement, T data)
636
 
                {
637
 
                        var handler = ThrowStatementVisited;
638
 
                        if (handler != null)
639
 
                                handler (throwStatement, data);
640
 
                        return VisitChildren (throwStatement, data);
641
 
                }
642
 
                
643
 
                public event Action<TryCatchStatement, T> TryCatchStatementVisited;
644
 
 
645
 
                S IAstVisitor<T, S>.VisitTryCatchStatement (TryCatchStatement tryCatchStatement, T data)
646
 
                {
647
 
                        var handler = TryCatchStatementVisited;
648
 
                        if (handler != null)
649
 
                                handler (tryCatchStatement, data);
650
 
                        return VisitChildren (tryCatchStatement, data);
651
 
                }
652
 
                
653
 
                public event Action<CatchClause, T> CatchClauseVisited;
654
 
 
655
 
                S IAstVisitor<T, S>.VisitCatchClause (CatchClause catchClause, T data)
656
 
                {
657
 
                        var handler = CatchClauseVisited;
658
 
                        if (handler != null)
659
 
                                handler (catchClause, data);
660
 
                        return VisitChildren (catchClause, data);
661
 
                }
662
 
                
663
 
                public event Action<UncheckedStatement, T> UncheckedStatementVisited;
664
 
 
665
 
                S IAstVisitor<T, S>.VisitUncheckedStatement (UncheckedStatement uncheckedStatement, T data)
666
 
                {
667
 
                        var handler = UncheckedStatementVisited;
668
 
                        if (handler != null)
669
 
                                handler (uncheckedStatement, data);
670
 
                        return VisitChildren (uncheckedStatement, data);
671
 
                }
672
 
                
673
 
                public event Action<UnsafeStatement, T> UnsafeStatementVisited;
674
 
 
675
 
                S IAstVisitor<T, S>.VisitUnsafeStatement (UnsafeStatement unsafeStatement, T data)
676
 
                {
677
 
                        var handler = UnsafeStatementVisited;
678
 
                        if (handler != null)
679
 
                                handler (unsafeStatement, data);
680
 
                        return VisitChildren (unsafeStatement, data);
681
 
                }
682
 
                
683
 
                public event Action<UsingStatement, T> UsingStatementVisited;
684
 
 
685
 
                S IAstVisitor<T, S>.VisitUsingStatement (UsingStatement usingStatement, T data)
686
 
                {
687
 
                        var handler = UsingStatementVisited;
688
 
                        if (handler != null)
689
 
                                handler (usingStatement, data);
690
 
                        return VisitChildren (usingStatement, data);
691
 
                }
692
 
                
693
 
                public event Action<VariableDeclarationStatement, T> VariableDeclarationStatementVisited;
694
 
 
695
 
                S IAstVisitor<T, S>.VisitVariableDeclarationStatement (VariableDeclarationStatement variableDeclarationStatement, T data)
696
 
                {
697
 
                        var handler = VariableDeclarationStatementVisited;
698
 
                        if (handler != null)
699
 
                                handler (variableDeclarationStatement, data);
700
 
                        return VisitChildren (variableDeclarationStatement, data);
701
 
                }
702
 
                
703
 
                public event Action<WhileStatement, T> WhileStatementVisited;
704
 
 
705
 
                S IAstVisitor<T, S>.VisitWhileStatement (WhileStatement whileStatement, T data)
706
 
                {
707
 
                        var handler = WhileStatementVisited;
708
 
                        if (handler != null)
709
 
                                handler (whileStatement, data);
710
 
                        return VisitChildren (whileStatement, data);
711
 
                }
712
 
                
713
 
                public event Action<YieldBreakStatement, T> YieldBreakStatementVisited;
714
 
 
715
 
                S IAstVisitor<T, S>.VisitYieldBreakStatement (YieldBreakStatement yieldBreakStatement, T data)
716
 
                {
717
 
                        var handler = YieldBreakStatementVisited;
718
 
                        if (handler != null)
719
 
                                handler (yieldBreakStatement, data);
720
 
                        return VisitChildren (yieldBreakStatement, data);
721
 
                }
722
 
                
723
 
                public event Action<YieldReturnStatement, T> YieldReturnStatementVisited;
724
 
 
725
 
                S IAstVisitor<T, S>.VisitYieldReturnStatement (YieldReturnStatement yieldStatement, T data)
726
 
                {
727
 
                        var handler = YieldReturnStatementVisited;
728
 
                        if (handler != null)
729
 
                                handler (yieldStatement, data);
730
 
                        return VisitChildren (yieldStatement, data);
731
 
                }
732
 
                
733
 
                public event Action<AnonymousMethodExpression, T> AnonymousMethodExpressionVisited;
734
 
 
735
 
                S IAstVisitor<T, S>.VisitAnonymousMethodExpression (AnonymousMethodExpression anonymousMethodExpression, T data)
736
 
                {
737
 
                        var handler = AnonymousMethodExpressionVisited;
738
 
                        if (handler != null)
739
 
                                handler (anonymousMethodExpression, data);
740
 
                        return VisitChildren (anonymousMethodExpression, data);
741
 
                }
742
 
                
743
 
                public event Action<LambdaExpression, T> LambdaExpressionVisited;
744
 
 
745
 
                S IAstVisitor<T, S>.VisitLambdaExpression (LambdaExpression lambdaExpression, T data)
746
 
                {
747
 
                        var handler = LambdaExpressionVisited;
748
 
                        if (handler != null)
749
 
                                handler (lambdaExpression, data);
750
 
                        return VisitChildren (lambdaExpression, data);
751
 
                }
752
 
                
753
 
                public event Action<AssignmentExpression, T> AssignmentExpressionVisited;
754
 
 
755
 
                S IAstVisitor<T, S>.VisitAssignmentExpression (AssignmentExpression assignmentExpression, T data)
756
 
                {
757
 
                        var handler = AssignmentExpressionVisited;
758
 
                        if (handler != null)
759
 
                                handler (assignmentExpression, data);
760
 
                        return VisitChildren (assignmentExpression, data);
761
 
                }
762
 
                
763
 
                public event Action<BaseReferenceExpression, T> BaseReferenceExpressionVisited;
764
 
 
765
 
                S IAstVisitor<T, S>.VisitBaseReferenceExpression (BaseReferenceExpression baseReferenceExpression, T data)
766
 
                {
767
 
                        var handler = BaseReferenceExpressionVisited;
768
 
                        if (handler != null)
769
 
                                handler (baseReferenceExpression, data);
770
 
                        return VisitChildren (baseReferenceExpression, data);
771
 
                }
772
 
                
773
 
                public event Action<BinaryOperatorExpression, T> BinaryOperatorExpressionVisited;
774
 
 
775
 
                S IAstVisitor<T, S>.VisitBinaryOperatorExpression (BinaryOperatorExpression binaryOperatorExpression, T data)
776
 
                {
777
 
                        var handler = BinaryOperatorExpressionVisited;
778
 
                        if (handler != null)
779
 
                                handler (binaryOperatorExpression, data);
780
 
                        return VisitChildren (binaryOperatorExpression, data);
781
 
                }
782
 
                
783
 
                public event Action<CastExpression, T> CastExpressionVisited;
784
 
 
785
 
                S IAstVisitor<T, S>.VisitCastExpression (CastExpression castExpression, T data)
786
 
                {
787
 
                        var handler = CastExpressionVisited;
788
 
                        if (handler != null)
789
 
                                handler (castExpression, data);
790
 
                        return VisitChildren (castExpression, data);
791
 
                }
792
 
                
793
 
                public event Action<CheckedExpression, T> CheckedExpressionVisited;
794
 
 
795
 
                S IAstVisitor<T, S>.VisitCheckedExpression (CheckedExpression checkedExpression, T data)
796
 
                {
797
 
                        var handler = CheckedExpressionVisited;
798
 
                        if (handler != null)
799
 
                                handler (checkedExpression, data);
800
 
                        return VisitChildren (checkedExpression, data);
801
 
                }
802
 
                
803
 
                public event Action<ConditionalExpression, T> ConditionalExpressionVisited;
804
 
 
805
 
                S IAstVisitor<T, S>.VisitConditionalExpression (ConditionalExpression conditionalExpression, T data)
806
 
                {
807
 
                        var handler = ConditionalExpressionVisited;
808
 
                        if (handler != null)
809
 
                                handler (conditionalExpression, data);
810
 
                        return VisitChildren (conditionalExpression, data);
811
 
                }
812
 
                
813
 
                public event Action<IdentifierExpression, T> IdentifierExpressionVisited;
814
 
 
815
 
                S IAstVisitor<T, S>.VisitIdentifierExpression (IdentifierExpression identifierExpression, T data)
816
 
                {
817
 
                        var handler = IdentifierExpressionVisited;
818
 
                        if (handler != null)
819
 
                                handler (identifierExpression, data);
820
 
                        return VisitChildren (identifierExpression, data);
821
 
                }
822
 
                
823
 
                public event Action<IndexerExpression, T> IndexerExpressionVisited;
824
 
 
825
 
                S IAstVisitor<T, S>.VisitIndexerExpression (IndexerExpression indexerExpression, T data)
826
 
                {
827
 
                        var handler = IndexerExpressionVisited;
828
 
                        if (handler != null)
829
 
                                handler (indexerExpression, data);
830
 
                        return VisitChildren (indexerExpression, data);
831
 
                }
832
 
                
833
 
                public event Action<InvocationExpression, T> InvocationExpressionVisited;
834
 
 
835
 
                S IAstVisitor<T, S>.VisitInvocationExpression (InvocationExpression invocationExpression, T data)
836
 
                {
837
 
                        var handler = InvocationExpressionVisited;
838
 
                        if (handler != null)
839
 
                                handler (invocationExpression, data);
840
 
                        return VisitChildren (invocationExpression, data);
841
 
                }
842
 
                
843
 
                public event Action<DirectionExpression, T> DirectionExpressionVisited;
844
 
 
845
 
                S IAstVisitor<T, S>.VisitDirectionExpression (DirectionExpression directionExpression, T data)
846
 
                {
847
 
                        var handler = DirectionExpressionVisited;
848
 
                        if (handler != null)
849
 
                                handler (directionExpression, data);
850
 
                        return VisitChildren (directionExpression, data);
851
 
                }
852
 
                
853
 
                public event Action<MemberReferenceExpression, T> MemberReferenceExpressionVisited;
854
 
 
855
 
                S IAstVisitor<T, S>.VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression, T data)
856
 
                {
857
 
                        var handler = MemberReferenceExpressionVisited;
858
 
                        if (handler != null)
859
 
                                handler (memberReferenceExpression, data);
860
 
                        return VisitChildren (memberReferenceExpression, data);
861
 
                }
862
 
                
863
 
                public event Action<NullReferenceExpression, T> NullReferenceExpressionVisited;
864
 
 
865
 
                S IAstVisitor<T, S>.VisitNullReferenceExpression (NullReferenceExpression nullReferenceExpression, T data)
866
 
                {
867
 
                        var handler = NullReferenceExpressionVisited;
868
 
                        if (handler != null)
869
 
                                handler (nullReferenceExpression, data);
870
 
                        return VisitChildren (nullReferenceExpression, data);
871
 
                }
872
 
                
873
 
                public event Action<ObjectCreateExpression, T> ObjectCreateExpressionVisited;
874
 
 
875
 
                S IAstVisitor<T, S>.VisitObjectCreateExpression (ObjectCreateExpression objectCreateExpression, T data)
876
 
                {
877
 
                        var handler = ObjectCreateExpressionVisited;
878
 
                        if (handler != null)
879
 
                                handler (objectCreateExpression, data);
880
 
                        return VisitChildren (objectCreateExpression, data);
881
 
                }
882
 
                
883
 
                public event Action<AnonymousTypeCreateExpression, T> AnonymousTypeCreateExpressionVisited;
884
 
 
885
 
                S IAstVisitor<T, S>.VisitAnonymousTypeCreateExpression (AnonymousTypeCreateExpression anonymousTypeCreateExpression, T data)
886
 
                {
887
 
                        var handler = AnonymousTypeCreateExpressionVisited;
888
 
                        if (handler != null)
889
 
                                handler (anonymousTypeCreateExpression, data);
890
 
                        return VisitChildren (anonymousTypeCreateExpression, data);
891
 
                }
892
 
                
893
 
                public event Action<ArrayCreateExpression, T> ArrayCreateExpressionVisited;
894
 
 
895
 
                S IAstVisitor<T, S>.VisitArrayCreateExpression (ArrayCreateExpression arraySCreateExpression, T data)
896
 
                {
897
 
                        var handler = ArrayCreateExpressionVisited;
898
 
                        if (handler != null)
899
 
                                handler (arraySCreateExpression, data);
900
 
                        return VisitChildren (arraySCreateExpression, data);
901
 
                }
902
 
                
903
 
                public event Action<ParenthesizedExpression, T> ParenthesizedExpressionVisited;
904
 
 
905
 
                S IAstVisitor<T, S>.VisitParenthesizedExpression (ParenthesizedExpression parenthesizedExpression, T data)
906
 
                {
907
 
                        var handler = ParenthesizedExpressionVisited;
908
 
                        if (handler != null)
909
 
                                handler (parenthesizedExpression, data);
910
 
                        return VisitChildren (parenthesizedExpression, data);
911
 
                }
912
 
                
913
 
                public event Action<PointerReferenceExpression, T> PointerReferenceExpressionVisited;
914
 
 
915
 
                S IAstVisitor<T, S>.VisitPointerReferenceExpression (PointerReferenceExpression pointerReferenceExpression, T data)
916
 
                {
917
 
                        var handler = PointerReferenceExpressionVisited;
918
 
                        if (handler != null)
919
 
                                handler (pointerReferenceExpression, data);
920
 
                        return VisitChildren (pointerReferenceExpression, data);
921
 
                }
922
 
                
923
 
                public event Action<PrimitiveExpression, T> PrimitiveExpressionVisited;
924
 
 
925
 
                S IAstVisitor<T, S>.VisitPrimitiveExpression (PrimitiveExpression primitiveExpression, T data)
926
 
                {
927
 
                        var handler = PrimitiveExpressionVisited;
928
 
                        if (handler != null)
929
 
                                handler (primitiveExpression, data);
930
 
                        return VisitChildren (primitiveExpression, data);
931
 
                }
932
 
                
933
 
                public event Action<SizeOfExpression, T> SizeOfExpressionVisited;
934
 
 
935
 
                S IAstVisitor<T, S>.VisitSizeOfExpression (SizeOfExpression sizeOfExpression, T data)
936
 
                {
937
 
                        var handler = SizeOfExpressionVisited;
938
 
                        if (handler != null)
939
 
                                handler (sizeOfExpression, data);
940
 
                        return VisitChildren (sizeOfExpression, data);
941
 
                }
942
 
                
943
 
                public event Action<StackAllocExpression, T> StackAllocExpressionVisited;
944
 
 
945
 
                S IAstVisitor<T, S>.VisitStackAllocExpression (StackAllocExpression stackAllocExpression, T data)
946
 
                {
947
 
                        var handler = StackAllocExpressionVisited;
948
 
                        if (handler != null)
949
 
                                handler (stackAllocExpression, data);
950
 
                        return VisitChildren (stackAllocExpression, data);
951
 
                }
952
 
                
953
 
                public event Action<ThisReferenceExpression, T> ThisReferenceExpressionVisited;
954
 
 
955
 
                S IAstVisitor<T, S>.VisitThisReferenceExpression (ThisReferenceExpression thisReferenceExpression, T data)
956
 
                {
957
 
                        var handler = ThisReferenceExpressionVisited;
958
 
                        if (handler != null)
959
 
                                handler (thisReferenceExpression, data);
960
 
                        return VisitChildren (thisReferenceExpression, data);
961
 
                }
962
 
                
963
 
                public event Action<TypeOfExpression, T> TypeOfExpressionVisited;
964
 
 
965
 
                S IAstVisitor<T, S>.VisitTypeOfExpression (TypeOfExpression typeOfExpression, T data)
966
 
                {
967
 
                        var handler = TypeOfExpressionVisited;
968
 
                        if (handler != null)
969
 
                                handler (typeOfExpression, data);
970
 
                        return VisitChildren (typeOfExpression, data);
971
 
                }
972
 
                
973
 
                public event Action<TypeReferenceExpression, T> TypeReferenceExpressionVisited;
974
 
 
975
 
                S IAstVisitor<T, S>.VisitTypeReferenceExpression (TypeReferenceExpression typeReferenceExpression, T data)
976
 
                {
977
 
                        var handler = TypeReferenceExpressionVisited;
978
 
                        if (handler != null)
979
 
                                handler (typeReferenceExpression, data);
980
 
                        return VisitChildren (typeReferenceExpression, data);
981
 
                }
982
 
                
983
 
                public event Action<UnaryOperatorExpression, T> UnaryOperatorExpressionVisited;
984
 
 
985
 
                S IAstVisitor<T, S>.VisitUnaryOperatorExpression (UnaryOperatorExpression unaryOperatorExpression, T data)
986
 
                {
987
 
                        var handler = UnaryOperatorExpressionVisited;
988
 
                        if (handler != null)
989
 
                                handler (unaryOperatorExpression, data);
990
 
                        return VisitChildren (unaryOperatorExpression, data);
991
 
                }
992
 
                
993
 
                public event Action<UncheckedExpression, T> UncheckedExpressionVisited;
994
 
 
995
 
                S IAstVisitor<T, S>.VisitUncheckedExpression (UncheckedExpression uncheckedExpression, T data)
996
 
                {
997
 
                        var handler = UncheckedExpressionVisited;
998
 
                        if (handler != null)
999
 
                                handler (uncheckedExpression, data);
1000
 
                        return VisitChildren (uncheckedExpression, data);
1001
 
                }
1002
 
                
1003
 
                public event Action<QueryExpression, T> QueryExpressionVisited;
1004
 
 
1005
 
                S IAstVisitor<T, S>.VisitQueryExpression (QueryExpression queryExpression, T data)
1006
 
                {
1007
 
                        var handler = QueryExpressionVisited;
1008
 
                        if (handler != null)
1009
 
                                handler (queryExpression, data);
1010
 
                        return VisitChildren (queryExpression, data);
1011
 
                }
1012
 
                
1013
 
                public event Action<QueryContinuationClause, T> QueryContinuationClauseVisited;
1014
 
 
1015
 
                S IAstVisitor<T, S>.VisitQueryContinuationClause (QueryContinuationClause queryContinuationClause, T data)
1016
 
                {
1017
 
                        var handler = QueryContinuationClauseVisited;
1018
 
                        if (handler != null)
1019
 
                                handler (queryContinuationClause, data);
1020
 
                        return VisitChildren (queryContinuationClause, data);
1021
 
                }
1022
 
                
1023
 
                public event Action<QueryFromClause, T> QueryFromClauseVisited;
1024
 
 
1025
 
                S IAstVisitor<T, S>.VisitQueryFromClause (QueryFromClause queryFromClause, T data)
1026
 
                {
1027
 
                        var handler = QueryFromClauseVisited;
1028
 
                        if (handler != null)
1029
 
                                handler (queryFromClause, data);
1030
 
                        return VisitChildren (queryFromClause, data);
1031
 
                }
1032
 
                
1033
 
                public event Action<QueryLetClause, T> QueryLetClauseVisited;
1034
 
 
1035
 
                S IAstVisitor<T, S>.VisitQueryLetClause (QueryLetClause queryLetClause, T data)
1036
 
                {
1037
 
                        var handler = QueryLetClauseVisited;
1038
 
                        if (handler != null)
1039
 
                                handler (queryLetClause, data);
1040
 
                        return VisitChildren (queryLetClause, data);
1041
 
                }
1042
 
                
1043
 
                public event Action<QueryWhereClause, T> QueryWhereClauseVisited;
1044
 
 
1045
 
                S IAstVisitor<T, S>.VisitQueryWhereClause (QueryWhereClause queryWhereClause, T data)
1046
 
                {
1047
 
                        var handler = QueryWhereClauseVisited;
1048
 
                        if (handler != null)
1049
 
                                handler (queryWhereClause, data);
1050
 
                        return VisitChildren (queryWhereClause, data);
1051
 
                }
1052
 
                
1053
 
                public event Action<QueryJoinClause, T> QueryJoinClauseVisited;
1054
 
 
1055
 
                S IAstVisitor<T, S>.VisitQueryJoinClause (QueryJoinClause queryJoinClause, T data)
1056
 
                {
1057
 
                        var handler = QueryJoinClauseVisited;
1058
 
                        if (handler != null)
1059
 
                                handler (queryJoinClause, data);
1060
 
                        return VisitChildren (queryJoinClause, data);
1061
 
                }
1062
 
                
1063
 
                public event Action<QueryOrderClause, T> QueryOrderClauseVisited;
1064
 
 
1065
 
                S IAstVisitor<T, S>.VisitQueryOrderClause (QueryOrderClause queryOrderClause, T data)
1066
 
                {
1067
 
                        var handler = QueryOrderClauseVisited;
1068
 
                        if (handler != null)
1069
 
                                handler (queryOrderClause, data);
1070
 
                        return VisitChildren (queryOrderClause, data);
1071
 
                }
1072
 
                
1073
 
                public event Action<QueryOrdering, T> QueryOrderingVisited;
1074
 
 
1075
 
                S IAstVisitor<T, S>.VisitQueryOrdering (QueryOrdering queryOrdering, T data)
1076
 
                {
1077
 
                        var handler = QueryOrderingVisited;
1078
 
                        if (handler != null)
1079
 
                                handler (queryOrdering, data);
1080
 
                        return VisitChildren (queryOrdering, data);
1081
 
                }
1082
 
                
1083
 
                public event Action<QuerySelectClause, T> QuerySelectClauseVisited;
1084
 
 
1085
 
                S IAstVisitor<T, S>.VisitQuerySelectClause (QuerySelectClause querySelectClause, T data)
1086
 
                {
1087
 
                        var handler = QuerySelectClauseVisited;
1088
 
                        if (handler != null)
1089
 
                                handler (querySelectClause, data);
1090
 
                        return VisitChildren (querySelectClause, data);
1091
 
                }
1092
 
                
1093
 
                public event Action<QueryGroupClause, T> QueryGroupClauseVisited;
1094
 
 
1095
 
                S IAstVisitor<T, S>.VisitQueryGroupClause (QueryGroupClause queryGroupClause, T data)
1096
 
                {
1097
 
                        var handler = QueryGroupClauseVisited;
1098
 
                        if (handler != null)
1099
 
                                handler (queryGroupClause, data);
1100
 
                        return VisitChildren (queryGroupClause, data);
1101
 
                }
1102
 
                
1103
 
                public event Action<AsExpression, T> AsExpressionVisited;
1104
 
 
1105
 
                S IAstVisitor<T, S>.VisitAsExpression (AsExpression asExpression, T data)
1106
 
                {
1107
 
                        var handler = AsExpressionVisited;
1108
 
                        if (handler != null)
1109
 
                                handler (asExpression, data);
1110
 
                        return VisitChildren (asExpression, data);
1111
 
                }
1112
 
                
1113
 
                public event Action<IsExpression, T> IsExpressionVisited;
1114
 
 
1115
 
                S IAstVisitor<T, S>.VisitIsExpression (IsExpression isExpression, T data)
1116
 
                {
1117
 
                        var handler = IsExpressionVisited;
1118
 
                        if (handler != null)
1119
 
                                handler (isExpression, data);
1120
 
                        return VisitChildren (isExpression, data);
1121
 
                }
1122
 
                
1123
 
                public event Action<DefaultValueExpression, T> DefaultValueExpressionVisited;
1124
 
 
1125
 
                S IAstVisitor<T, S>.VisitDefaultValueExpression (DefaultValueExpression defaultValueExpression, T data)
1126
 
                {
1127
 
                        var handler = DefaultValueExpressionVisited;
1128
 
                        if (handler != null)
1129
 
                                handler (defaultValueExpression, data);
1130
 
                        return VisitChildren (defaultValueExpression, data);
1131
 
                }
1132
 
                
1133
 
                public event Action<UndocumentedExpression, T> UndocumentedExpressionVisited;
1134
 
 
1135
 
                S IAstVisitor<T, S>.VisitUndocumentedExpression (UndocumentedExpression undocumentedExpression, T data)
1136
 
                {
1137
 
                        var handler = UndocumentedExpressionVisited;
1138
 
                        if (handler != null)
1139
 
                                handler (undocumentedExpression, data);
1140
 
                        return VisitChildren (undocumentedExpression, data);
1141
 
                }
1142
 
                
1143
 
                public event Action<ArrayInitializerExpression, T> ArrayInitializerExpressionVisited;
1144
 
 
1145
 
                S IAstVisitor<T, S>.VisitArrayInitializerExpression (ArrayInitializerExpression arrayInitializerExpression, T data)
1146
 
                {
1147
 
                        var handler = ArrayInitializerExpressionVisited;
1148
 
                        if (handler != null)
1149
 
                                handler (arrayInitializerExpression, data);
1150
 
                        return VisitChildren (arrayInitializerExpression, data);
1151
 
                }
1152
 
                
1153
 
                public event Action<ArraySpecifier, T> ArraySpecifierVisited;
1154
 
 
1155
 
                S IAstVisitor<T, S>.VisitArraySpecifier (ArraySpecifier arraySpecifier, T data)
1156
 
                {
1157
 
                        var handler = ArraySpecifierVisited;
1158
 
                        if (handler != null)
1159
 
                                handler (arraySpecifier, data);
1160
 
                        return VisitChildren (arraySpecifier, data);
1161
 
                }
1162
 
                
1163
 
                public event Action<NamedArgumentExpression, T> NamedArgumentExpressionVisited;
1164
 
 
1165
 
                S IAstVisitor<T, S>.VisitNamedArgumentExpression (NamedArgumentExpression namedArgumentExpression, T data)
1166
 
                {
1167
 
                        var handler = NamedArgumentExpressionVisited;
1168
 
                        if (handler != null)
1169
 
                                handler (namedArgumentExpression, data);
1170
 
                        return VisitChildren (namedArgumentExpression, data);
1171
 
                }
1172
 
                
1173
 
                public event Action<NamedExpression, T> NamedExpressionVisited;
1174
 
 
1175
 
                S IAstVisitor<T, S>.VisitNamedExpression (NamedExpression namedExpression, T data)
1176
 
                {
1177
 
                        var handler = NamedExpressionVisited;
1178
 
                        if (handler != null)
1179
 
                                handler (namedExpression, data);
1180
 
                        return VisitChildren (namedExpression, data);
1181
 
                }
1182
 
                
1183
 
                public event Action<EmptyExpression, T> EmptyExpressionVisited;
1184
 
 
1185
 
                S IAstVisitor<T, S>.VisitEmptyExpression (EmptyExpression emptyExpression, T data)
1186
 
                {
1187
 
                        var handler = EmptyExpressionVisited;
1188
 
                        if (handler != null)
1189
 
                                handler (emptyExpression, data);
1190
 
                        return VisitChildren (emptyExpression, data);
1191
 
                }
1192
 
                
1193
 
                S IAstVisitor<T, S>.VisitPatternPlaceholder (AstNode placeholder, PatternMatching.Pattern pattern, T data)
1194
 
                {
1195
 
                        return VisitChildren (placeholder, data);
1196
 
                }
1197
 
        }
1198
 
}
1199
 
 
1200