← Back to branch summary

~ubuntu-branches/ubuntu/saucy/monodevelop/saucy

« 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: 2012-05-27 18:08:20 UTC
  • mfrom: (1.8.5) (1.5.8 sid)
  • Revision ID: package-import@ubuntu.com-20120527180820-f1ub6lhg0s50wci1
Tags: 3.0.2+dfsg-3
* [fcecfe7] Fix monodevelop-core-addins.pc.in to point to actual 
  installed location of assemblies.
* [26e1a07] DebSrc 3.0 does not support Quilt's -p parameter, so 
  manually adjust the path in the patch file.

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