← Back to branch summary

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

« back to all changes in this revision

Viewing changes to external/nrefactory/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:
external/nrefactory/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
 
 
27
using System;
 
28
 
 
29
namespace ICSharpCode.NRefactory.CSharp
 
30
{
 
31
        public class ObservableAstVisitor : IAstVisitor
 
32
        {
 
33
                void Visit<T>(Action<T> enter, Action<T> leave, T node) where T : AstNode
 
34
                {
 
35
                        if (enter != null)
 
36
                                enter(node);
 
37
                        AstNode next;
 
38
                        for (var child = node.FirstChild; child != null; child = next) {
 
39
                                // Store next to allow the loop to continue
 
40
                                // if the visitor removes/replaces children.
 
41
                                next = child.NextSibling;
 
42
                                child.AcceptVisitor (this);
 
43
                        }
 
44
                        if (leave != null)
 
45
                                leave(node);
 
46
                }
 
47
                
 
48
                public event Action<SyntaxTree> EnterSyntaxTree, LeaveSyntaxTree;
 
49
                
 
50
                void IAstVisitor.VisitSyntaxTree(SyntaxTree unit)
 
51
                {
 
52
                        Visit(EnterSyntaxTree, LeaveSyntaxTree, unit);
 
53
                }
 
54
                
 
55
                public event Action<Comment> EnterComment, LeaveComment;
 
56
                
 
57
                void IAstVisitor.VisitComment(Comment comment)
 
58
                {
 
59
                        Visit(EnterComment, LeaveComment, comment);
 
60
                }
 
61
                
 
62
                public event Action<NewLineNode> EnterNewLine, LeaveNewLine;
 
63
                
 
64
                void IAstVisitor.VisitNewLine(NewLineNode newLineNode)
 
65
                {
 
66
                        Visit(EnterNewLine, LeaveNewLine, newLineNode);
 
67
                }
 
68
                
 
69
                public event Action<WhitespaceNode> EnterWhitespace, LeaveWhitespace;
 
70
                
 
71
                void IAstVisitor.VisitWhitespace(WhitespaceNode whitespace)
 
72
                {
 
73
                        Visit(EnterWhitespace, LeaveWhitespace, whitespace);
 
74
                }
 
75
                
 
76
                public event Action<TextNode> EnterText, LeaveText;
 
77
                
 
78
                void IAstVisitor.VisitText(TextNode textNode)
 
79
                {
 
80
                        Visit(EnterText, LeaveText, textNode);
 
81
                }
 
82
                
 
83
                public event Action<PreProcessorDirective> EnterPreProcessorDirective, LeavePreProcessorDirective;
 
84
                void IAstVisitor.VisitPreProcessorDirective(PreProcessorDirective preProcessorDirective)
 
85
                {
 
86
                        Visit(EnterPreProcessorDirective, LeavePreProcessorDirective, preProcessorDirective);
 
87
                }
 
88
                
 
89
                public event Action<DocumentationReference> EnterDocumentationReference, LeaveDocumentationReference;
 
90
                
 
91
                void IAstVisitor.VisitDocumentationReference(DocumentationReference documentationReference)
 
92
                {
 
93
                        Visit(EnterDocumentationReference, LeaveDocumentationReference, documentationReference);
 
94
                }
 
95
                
 
96
                public event Action<Identifier> EnterIdentifier, LeaveIdentifier;
 
97
                
 
98
                void IAstVisitor.VisitIdentifier(Identifier identifier)
 
99
                {
 
100
                        Visit(EnterIdentifier, LeaveIdentifier, identifier);
 
101
                }
 
102
                
 
103
                public event Action<CSharpTokenNode> EnterCSharpTokenNode, LeaveCSharpTokenNode;
 
104
                
 
105
                void IAstVisitor.VisitCSharpTokenNode(CSharpTokenNode token)
 
106
                {
 
107
                        Visit(EnterCSharpTokenNode, LeaveCSharpTokenNode, token);
 
108
                }
 
109
                
 
110
                public event Action<PrimitiveType> EnterPrimitiveType, LeavePrimitiveType;
 
111
                
 
112
                void IAstVisitor.VisitPrimitiveType(PrimitiveType primitiveType)
 
113
                {
 
114
                        Visit(EnterPrimitiveType, LeavePrimitiveType, primitiveType);
 
115
                }
 
116
                
 
117
                public event Action<ComposedType> EnterComposedType, LeaveComposedType;
 
118
                
 
119
                void IAstVisitor.VisitComposedType(ComposedType composedType)
 
120
                {
 
121
                        Visit(EnterComposedType, LeaveComposedType, composedType);
 
122
                }
 
123
                
 
124
                public event Action<SimpleType> EnterSimpleType, LeaveSimpleType;
 
125
                
 
126
                void IAstVisitor.VisitSimpleType(SimpleType simpleType)
 
127
                {
 
128
                        Visit(EnterSimpleType, LeaveSimpleType, simpleType);
 
129
                }
 
130
                
 
131
                public event Action<MemberType> EnterMemberType, LeaveMemberType;
 
132
                
 
133
                void IAstVisitor.VisitMemberType(MemberType memberType)
 
134
                {
 
135
                        Visit(EnterMemberType, LeaveMemberType, memberType);
 
136
                }
 
137
                
 
138
                public event Action<Attribute> EnterAttribute, LeaveAttribute;
 
139
                
 
140
                void IAstVisitor.VisitAttribute(Attribute attribute)
 
141
                {
 
142
                        Visit(EnterAttribute, LeaveAttribute, attribute);
 
143
                }
 
144
                
 
145
                public event Action<AttributeSection> EnterAttributeSection, LeaveAttributeSection;
 
146
                
 
147
                void IAstVisitor.VisitAttributeSection(AttributeSection attributeSection)
 
148
                {
 
149
                        Visit(EnterAttributeSection, LeaveAttributeSection, attributeSection);
 
150
                }
 
151
                
 
152
                public event Action<DelegateDeclaration> EnterDelegateDeclaration, LeaveDelegateDeclaration;
 
153
                
 
154
                void IAstVisitor.VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration)
 
155
                {
 
156
                        Visit(EnterDelegateDeclaration, LeaveDelegateDeclaration, delegateDeclaration);
 
157
                }
 
158
                
 
159
                public event Action<NamespaceDeclaration> EnterNamespaceDeclaration, LeaveNamespaceDeclaration;
 
160
                
 
161
                void IAstVisitor.VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration)
 
162
                {
 
163
                        Visit(EnterNamespaceDeclaration, LeaveNamespaceDeclaration, namespaceDeclaration);
 
164
                }
 
165
                
 
166
                public event Action<TypeDeclaration> EnterTypeDeclaration, LeaveTypeDeclaration;
 
167
                
 
168
                void IAstVisitor.VisitTypeDeclaration(TypeDeclaration typeDeclaration)
 
169
                {
 
170
                        Visit(EnterTypeDeclaration, LeaveTypeDeclaration, typeDeclaration);
 
171
                }
 
172
                
 
173
                public event Action<TypeParameterDeclaration> EnterTypeParameterDeclaration, LeaveTypeParameterDeclaration;
 
174
                
 
175
                void IAstVisitor.VisitTypeParameterDeclaration(TypeParameterDeclaration typeParameterDeclaration)
 
176
                {
 
177
                        Visit(EnterTypeParameterDeclaration, LeaveTypeParameterDeclaration, typeParameterDeclaration);
 
178
                }
 
179
                
 
180
                public event Action<EnumMemberDeclaration> EnterEnumMemberDeclaration, LeaveEnumMemberDeclaration;
 
181
                
 
182
                void IAstVisitor.VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration)
 
183
                {
 
184
                        Visit(EnterEnumMemberDeclaration, LeaveEnumMemberDeclaration, enumMemberDeclaration);
 
185
                }
 
186
                
 
187
                public event Action<UsingDeclaration> EnterUsingDeclaration, LeaveUsingDeclaration;
 
188
                
 
189
                void IAstVisitor.VisitUsingDeclaration(UsingDeclaration usingDeclaration)
 
190
                {
 
191
                        Visit(EnterUsingDeclaration, LeaveUsingDeclaration, usingDeclaration);
 
192
                }
 
193
                
 
194
                public event Action<UsingAliasDeclaration> EnterUsingAliasDeclaration, LeaveUsingAliasDeclaration;
 
195
                
 
196
                void IAstVisitor.VisitUsingAliasDeclaration(UsingAliasDeclaration usingDeclaration)
 
197
                {
 
198
                        Visit(EnterUsingAliasDeclaration, LeaveUsingAliasDeclaration, usingDeclaration);
 
199
                }
 
200
                
 
201
                public event Action<ExternAliasDeclaration> EnterExternAliasDeclaration, LeaveExternAliasDeclaration;
 
202
                
 
203
                void IAstVisitor.VisitExternAliasDeclaration(ExternAliasDeclaration externAliasDeclaration)
 
204
                {
 
205
                        Visit(EnterExternAliasDeclaration, LeaveExternAliasDeclaration, externAliasDeclaration);
 
206
                }
 
207
                
 
208
                public event Action<ConstructorDeclaration> EnterConstructorDeclaration, LeaveConstructorDeclaration;
 
209
                
 
210
                void IAstVisitor.VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration)
 
211
                {
 
212
                        Visit(EnterConstructorDeclaration, LeaveConstructorDeclaration, constructorDeclaration);
 
213
                }
 
214
                
 
215
                public event Action<ConstructorInitializer> EnterConstructorInitializer, LeaveConstructorInitializer;
 
216
                
 
217
                void IAstVisitor.VisitConstructorInitializer(ConstructorInitializer constructorInitializer)
 
218
                {
 
219
                        Visit(EnterConstructorInitializer, LeaveConstructorInitializer, constructorInitializer);
 
220
                }
 
221
                
 
222
                public event Action<DestructorDeclaration> EnterDestructorDeclaration, LeaveDestructorDeclaration;
 
223
                
 
224
                void IAstVisitor.VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration)
 
225
                {
 
226
                        Visit(EnterDestructorDeclaration, LeaveDestructorDeclaration, destructorDeclaration);
 
227
                }
 
228
                
 
229
                public event Action<EventDeclaration> EnterEventDeclaration, LeaveEventDeclaration;
 
230
                
 
231
                void IAstVisitor.VisitEventDeclaration(EventDeclaration eventDeclaration)
 
232
                {
 
233
                        Visit(EnterEventDeclaration, LeaveEventDeclaration, eventDeclaration);
 
234
                }
 
235
                
 
236
                public event Action<CustomEventDeclaration> EnterCustomEventDeclaration, LeaveCustomEventDeclaration;
 
237
                
 
238
                void IAstVisitor.VisitCustomEventDeclaration(CustomEventDeclaration eventDeclaration)
 
239
                {
 
240
                        Visit(EnterCustomEventDeclaration, LeaveCustomEventDeclaration, eventDeclaration);
 
241
                }
 
242
                
 
243
                public event Action<FieldDeclaration> EnterFieldDeclaration, LeaveFieldDeclaration;
 
244
                
 
245
                void IAstVisitor.VisitFieldDeclaration(FieldDeclaration fieldDeclaration)
 
246
                {
 
247
                        Visit(EnterFieldDeclaration, LeaveFieldDeclaration, fieldDeclaration);
 
248
                }
 
249
                
 
250
                public event Action<FixedFieldDeclaration> EnterFixedFieldDeclaration, LeaveFixedFieldDeclaration;
 
251
                
 
252
                void IAstVisitor.VisitFixedFieldDeclaration(FixedFieldDeclaration fixedFieldDeclaration)
 
253
                {
 
254
                        Visit(EnterFixedFieldDeclaration, LeaveFixedFieldDeclaration, fixedFieldDeclaration);
 
255
                }
 
256
                
 
257
                public event Action<FixedVariableInitializer> EnterFixedVariableInitializer, LeaveFixedVariableInitializer;
 
258
                
 
259
                void IAstVisitor.VisitFixedVariableInitializer(FixedVariableInitializer fixedVariableInitializer)
 
260
                {
 
261
                        Visit(EnterFixedVariableInitializer, LeaveFixedVariableInitializer, fixedVariableInitializer);
 
262
                }
 
263
                
 
264
                public event Action<IndexerDeclaration> EnterIndexerDeclaration, LeaveIndexerDeclaration;
 
265
                
 
266
                void IAstVisitor.VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration)
 
267
                {
 
268
                        Visit(EnterIndexerDeclaration, LeaveIndexerDeclaration, indexerDeclaration);
 
269
                }
 
270
                
 
271
                public event Action<MethodDeclaration> EnterMethodDeclaration, LeaveMethodDeclaration;
 
272
                
 
273
                void IAstVisitor.VisitMethodDeclaration(MethodDeclaration methodDeclaration)
 
274
                {
 
275
                        Visit(EnterMethodDeclaration, LeaveMethodDeclaration, methodDeclaration);
 
276
                }
 
277
                
 
278
                public event Action<OperatorDeclaration> EnterOperatorDeclaration, LeaveOperatorDeclaration;
 
279
                
 
280
                void IAstVisitor.VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration)
 
281
                {
 
282
                        Visit(EnterOperatorDeclaration, LeaveOperatorDeclaration, operatorDeclaration);
 
283
                }
 
284
                
 
285
                public event Action<PropertyDeclaration> EnterPropertyDeclaration, LeavePropertyDeclaration;
 
286
                
 
287
                void IAstVisitor.VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration)
 
288
                {
 
289
                        Visit(EnterPropertyDeclaration, LeavePropertyDeclaration, propertyDeclaration);
 
290
                }
 
291
                
 
292
                public event Action<Accessor> EnterAccessor, LeaveAccessor;
 
293
                
 
294
                void IAstVisitor.VisitAccessor(Accessor accessor)
 
295
                {
 
296
                        Visit(EnterAccessor, LeaveAccessor, accessor);
 
297
                }
 
298
                
 
299
                public event Action<VariableInitializer> EnterVariableInitializer, LeaveVariableInitializer;
 
300
                
 
301
                void IAstVisitor.VisitVariableInitializer(VariableInitializer variableInitializer)
 
302
                {
 
303
                        Visit(EnterVariableInitializer, LeaveVariableInitializer, variableInitializer);
 
304
                }
 
305
                
 
306
                public event Action<ParameterDeclaration> EnterParameterDeclaration, LeaveParameterDeclaration;
 
307
                
 
308
                void IAstVisitor.VisitParameterDeclaration(ParameterDeclaration parameterDeclaration)
 
309
                {
 
310
                        Visit(EnterParameterDeclaration, LeaveParameterDeclaration, parameterDeclaration);
 
311
                }
 
312
                
 
313
                public event Action<Constraint> EnterConstraint, LeaveConstraint;
 
314
                
 
315
                void IAstVisitor.VisitConstraint(Constraint constraint)
 
316
                {
 
317
                        Visit(EnterConstraint, LeaveConstraint, constraint);
 
318
                }
 
319
                
 
320
                public event Action<BlockStatement> EnterBlockStatement, LeaveBlockStatement;
 
321
                
 
322
                void IAstVisitor.VisitBlockStatement(BlockStatement blockStatement)
 
323
                {
 
324
                        Visit(EnterBlockStatement, LeaveBlockStatement, blockStatement);
 
325
                }
 
326
                
 
327
                public event Action<ExpressionStatement> EnterExpressionStatement, LeaveExpressionStatement;
 
328
                
 
329
                void IAstVisitor.VisitExpressionStatement(ExpressionStatement expressionStatement)
 
330
                {
 
331
                        Visit(EnterExpressionStatement, LeaveExpressionStatement, expressionStatement);
 
332
                }
 
333
                
 
334
                public event Action<BreakStatement> EnterBreakStatement, LeaveBreakStatement;
 
335
                
 
336
                void IAstVisitor.VisitBreakStatement(BreakStatement breakStatement)
 
337
                {
 
338
                        Visit(EnterBreakStatement, LeaveBreakStatement, breakStatement);
 
339
                }
 
340
                
 
341
                public event Action<CheckedStatement> EnterCheckedStatement, LeaveCheckedStatement;
 
342
                
 
343
                void IAstVisitor.VisitCheckedStatement(CheckedStatement checkedStatement)
 
344
                {
 
345
                        Visit(EnterCheckedStatement, LeaveCheckedStatement, checkedStatement);
 
346
                }
 
347
                
 
348
                public event Action<ContinueStatement> EnterContinueStatement, LeaveContinueStatement;
 
349
                
 
350
                void IAstVisitor.VisitContinueStatement(ContinueStatement continueStatement)
 
351
                {
 
352
                        Visit(EnterContinueStatement, LeaveContinueStatement, continueStatement);
 
353
                }
 
354
                
 
355
                public event Action<DoWhileStatement> EnterDoWhileStatement, LeaveDoWhileStatement;
 
356
                
 
357
                void IAstVisitor.VisitDoWhileStatement(DoWhileStatement doWhileStatement)
 
358
                {
 
359
                        Visit(EnterDoWhileStatement, LeaveDoWhileStatement, doWhileStatement);
 
360
                }
 
361
                
 
362
                public event Action<EmptyStatement> EnterEmptyStatement, LeaveEmptyStatement;
 
363
                
 
364
                void IAstVisitor.VisitEmptyStatement(EmptyStatement emptyStatement)
 
365
                {
 
366
                        Visit(EnterEmptyStatement, LeaveEmptyStatement, emptyStatement);
 
367
                }
 
368
                
 
369
                public event Action<FixedStatement> EnterFixedStatement, LeaveFixedStatement;
 
370
                
 
371
                void IAstVisitor.VisitFixedStatement(FixedStatement fixedStatement)
 
372
                {
 
373
                        Visit(EnterFixedStatement, LeaveFixedStatement, fixedStatement);
 
374
                }
 
375
                
 
376
                public event Action<ForeachStatement> EnterForeachStatement, LeaveForeachStatement;
 
377
                
 
378
                void IAstVisitor.VisitForeachStatement(ForeachStatement foreachStatement)
 
379
                {
 
380
                        Visit(EnterForeachStatement, LeaveForeachStatement, foreachStatement);
 
381
                }
 
382
                
 
383
                public event Action<ForStatement> EnterForStatement, LeaveForStatement;
 
384
                
 
385
                void IAstVisitor.VisitForStatement(ForStatement forStatement)
 
386
                {
 
387
                        Visit(EnterForStatement, LeaveForStatement, forStatement);
 
388
                }
 
389
                
 
390
                public event Action<GotoCaseStatement> EnterGotoCaseStatement, LeaveGotoCaseStatement;
 
391
                
 
392
                void IAstVisitor.VisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement)
 
393
                {
 
394
                        Visit(EnterGotoCaseStatement, LeaveGotoCaseStatement, gotoCaseStatement);
 
395
                }
 
396
                
 
397
                public event Action<GotoDefaultStatement> EnterGotoDefaultStatement, LeaveGotoDefaultStatement;
 
398
                
 
399
                void IAstVisitor.VisitGotoDefaultStatement(GotoDefaultStatement gotoDefaultStatement)
 
400
                {
 
401
                        Visit(EnterGotoDefaultStatement, LeaveGotoDefaultStatement, gotoDefaultStatement);
 
402
                }
 
403
                
 
404
                public event Action<GotoStatement> EnterGotoStatement, LeaveGotoStatement;
 
405
                
 
406
                void IAstVisitor.VisitGotoStatement(GotoStatement gotoStatement)
 
407
                {
 
408
                        Visit(EnterGotoStatement, LeaveGotoStatement, gotoStatement);
 
409
                }
 
410
                
 
411
                public event Action<IfElseStatement> EnterIfElseStatement, LeaveIfElseStatement;
 
412
                
 
413
                void IAstVisitor.VisitIfElseStatement(IfElseStatement ifElseStatement)
 
414
                {
 
415
                        Visit(EnterIfElseStatement, LeaveIfElseStatement, ifElseStatement);
 
416
                }
 
417
                
 
418
                public event Action<LabelStatement> EnterLabelStatement, LeaveLabelStatement;
 
419
                
 
420
                void IAstVisitor.VisitLabelStatement(LabelStatement labelStatement)
 
421
                {
 
422
                        Visit(EnterLabelStatement, LeaveLabelStatement, labelStatement);
 
423
                }
 
424
                
 
425
                public event Action<LockStatement> EnterLockStatement, LeaveLockStatement;
 
426
                
 
427
                void IAstVisitor.VisitLockStatement(LockStatement lockStatement)
 
428
                {
 
429
                        Visit(EnterLockStatement, LeaveLockStatement, lockStatement);
 
430
                }
 
431
                
 
432
                public event Action<ReturnStatement> EnterReturnStatement, LeaveReturnStatement;
 
433
                
 
434
                void IAstVisitor.VisitReturnStatement(ReturnStatement returnStatement)
 
435
                {
 
436
                        Visit(EnterReturnStatement, LeaveReturnStatement, returnStatement);
 
437
                }
 
438
                
 
439
                public event Action<SwitchStatement> EnterSwitchStatement, LeaveSwitchStatement;
 
440
                
 
441
                void IAstVisitor.VisitSwitchStatement(SwitchStatement switchStatement)
 
442
                {
 
443
                        Visit(EnterSwitchStatement, LeaveSwitchStatement, switchStatement);
 
444
                }
 
445
                
 
446
                public event Action<SwitchSection> EnterSwitchSection, LeaveSwitchSection;
 
447
                
 
448
                void IAstVisitor.VisitSwitchSection(SwitchSection switchSection)
 
449
                {
 
450
                        Visit(EnterSwitchSection, LeaveSwitchSection, switchSection);
 
451
                }
 
452
                
 
453
                public event Action<CaseLabel> EnterCaseLabel, LeaveCaseLabel;
 
454
                
 
455
                void IAstVisitor.VisitCaseLabel(CaseLabel caseLabel)
 
456
                {
 
457
                        Visit(EnterCaseLabel, LeaveCaseLabel, caseLabel);
 
458
                }
 
459
                
 
460
                public event Action<ThrowStatement> EnterThrowStatement, LeaveThrowStatement;
 
461
                
 
462
                void IAstVisitor.VisitThrowStatement(ThrowStatement throwStatement)
 
463
                {
 
464
                        Visit(EnterThrowStatement, LeaveThrowStatement, throwStatement);
 
465
                }
 
466
                
 
467
                public event Action<TryCatchStatement> EnterTryCatchStatement, LeaveTryCatchStatement;
 
468
                
 
469
                void IAstVisitor.VisitTryCatchStatement(TryCatchStatement tryCatchStatement)
 
470
                {
 
471
                        Visit(EnterTryCatchStatement, LeaveTryCatchStatement, tryCatchStatement);
 
472
                }
 
473
                
 
474
                public event Action<CatchClause> EnterCatchClause, LeaveCatchClause;
 
475
                
 
476
                void IAstVisitor.VisitCatchClause(CatchClause catchClause)
 
477
                {
 
478
                        Visit(EnterCatchClause, LeaveCatchClause, catchClause);
 
479
                }
 
480
                
 
481
                public event Action<UncheckedStatement> EnterUncheckedStatement, LeaveUncheckedStatement;
 
482
                
 
483
                void IAstVisitor.VisitUncheckedStatement(UncheckedStatement uncheckedStatement)
 
484
                {
 
485
                        Visit(EnterUncheckedStatement, LeaveUncheckedStatement, uncheckedStatement);
 
486
                }
 
487
                
 
488
                public event Action<UnsafeStatement> EnterUnsafeStatement, LeaveUnsafeStatement;
 
489
                
 
490
                void IAstVisitor.VisitUnsafeStatement(UnsafeStatement unsafeStatement)
 
491
                {
 
492
                        Visit(EnterUnsafeStatement, LeaveUnsafeStatement, unsafeStatement);
 
493
                }
 
494
                
 
495
                public event Action<UsingStatement> EnterUsingStatement, LeaveUsingStatement;
 
496
                
 
497
                void IAstVisitor.VisitUsingStatement(UsingStatement usingStatement)
 
498
                {
 
499
                        Visit(EnterUsingStatement, LeaveUsingStatement, usingStatement);
 
500
                }
 
501
                
 
502
                public event Action<VariableDeclarationStatement> EnterVariableDeclarationStatement, LeaveVariableDeclarationStatement;
 
503
                
 
504
                void IAstVisitor.VisitVariableDeclarationStatement(VariableDeclarationStatement variableDeclarationStatement)
 
505
                {
 
506
                        Visit(EnterVariableDeclarationStatement, LeaveVariableDeclarationStatement, variableDeclarationStatement);
 
507
                }
 
508
                
 
509
                public event Action<WhileStatement> EnterWhileStatement, LeaveWhileStatement;
 
510
                
 
511
                void IAstVisitor.VisitWhileStatement(WhileStatement whileStatement)
 
512
                {
 
513
                        Visit(EnterWhileStatement, LeaveWhileStatement, whileStatement);
 
514
                }
 
515
                
 
516
                public event Action<YieldBreakStatement> EnterYieldBreakStatement, LeaveYieldBreakStatement;
 
517
                
 
518
                void IAstVisitor.VisitYieldBreakStatement(YieldBreakStatement yieldBreakStatement)
 
519
                {
 
520
                        Visit(EnterYieldBreakStatement, LeaveYieldBreakStatement, yieldBreakStatement);
 
521
                }
 
522
                
 
523
                public event Action<YieldReturnStatement> EnterYieldReturnStatement, LeaveYieldReturnStatement;
 
524
                
 
525
                void IAstVisitor.VisitYieldReturnStatement(YieldReturnStatement yieldStatement)
 
526
                {
 
527
                        Visit(EnterYieldReturnStatement, LeaveYieldReturnStatement, yieldStatement);
 
528
                }
 
529
                
 
530
                public event Action<AnonymousMethodExpression> EnterAnonymousMethodExpression, LeaveAnonymousMethodExpression;
 
531
                
 
532
                void IAstVisitor.VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression)
 
533
                {
 
534
                        Visit(EnterAnonymousMethodExpression, LeaveAnonymousMethodExpression, anonymousMethodExpression);
 
535
                }
 
536
                
 
537
                public event Action<LambdaExpression> EnterLambdaExpression, LeaveLambdaExpression;
 
538
                
 
539
                void IAstVisitor.VisitLambdaExpression(LambdaExpression lambdaExpression)
 
540
                {
 
541
                        Visit(EnterLambdaExpression, LeaveLambdaExpression, lambdaExpression);
 
542
                }
 
543
                
 
544
                public event Action<AssignmentExpression> EnterAssignmentExpression, LeaveAssignmentExpression;
 
545
                
 
546
                void IAstVisitor.VisitAssignmentExpression(AssignmentExpression assignmentExpression)
 
547
                {
 
548
                        Visit(EnterAssignmentExpression, LeaveAssignmentExpression, assignmentExpression);
 
549
                }
 
550
                
 
551
                public event Action<BaseReferenceExpression> EnterBaseReferenceExpression, LeaveBaseReferenceExpression;
 
552
                
 
553
                void IAstVisitor.VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression)
 
554
                {
 
555
                        Visit(EnterBaseReferenceExpression, LeaveBaseReferenceExpression, baseReferenceExpression);
 
556
                }
 
557
                
 
558
                public event Action<BinaryOperatorExpression> EnterBinaryOperatorExpression, LeaveBinaryOperatorExpression;
 
559
                
 
560
                void IAstVisitor.VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression)
 
561
                {
 
562
                        Visit(EnterBinaryOperatorExpression, LeaveBinaryOperatorExpression, binaryOperatorExpression);
 
563
                }
 
564
                
 
565
                public event Action<CastExpression> EnterCastExpression, LeaveCastExpression;
 
566
                
 
567
                void IAstVisitor.VisitCastExpression(CastExpression castExpression)
 
568
                {
 
569
                        Visit(EnterCastExpression, LeaveCastExpression, castExpression);
 
570
                }
 
571
                
 
572
                public event Action<CheckedExpression> EnterCheckedExpression, LeaveCheckedExpression;
 
573
                
 
574
                void IAstVisitor.VisitCheckedExpression(CheckedExpression checkedExpression)
 
575
                {
 
576
                        Visit(EnterCheckedExpression, LeaveCheckedExpression, checkedExpression);
 
577
                }
 
578
                
 
579
                public event Action<ConditionalExpression> EnterConditionalExpression, LeaveConditionalExpression;
 
580
                
 
581
                void IAstVisitor.VisitConditionalExpression(ConditionalExpression conditionalExpression)
 
582
                {
 
583
                        Visit(EnterConditionalExpression, LeaveConditionalExpression, conditionalExpression);
 
584
                }
 
585
                
 
586
                public event Action<IdentifierExpression> EnterIdentifierExpression, LeaveIdentifierExpression;
 
587
                
 
588
                void IAstVisitor.VisitIdentifierExpression(IdentifierExpression identifierExpression)
 
589
                {
 
590
                        Visit(EnterIdentifierExpression, LeaveIdentifierExpression, identifierExpression);
 
591
                }
 
592
                
 
593
                public event Action<IndexerExpression> EnterIndexerExpression, LeaveIndexerExpression;
 
594
                
 
595
                void IAstVisitor.VisitIndexerExpression(IndexerExpression indexerExpression)
 
596
                {
 
597
                        Visit(EnterIndexerExpression, LeaveIndexerExpression, indexerExpression);
 
598
                }
 
599
                
 
600
                public event Action<InvocationExpression> EnterInvocationExpression, LeaveInvocationExpression;
 
601
                
 
602
                void IAstVisitor.VisitInvocationExpression(InvocationExpression invocationExpression)
 
603
                {
 
604
                        Visit(EnterInvocationExpression, LeaveInvocationExpression, invocationExpression);
 
605
                }
 
606
                
 
607
                public event Action<DirectionExpression> EnterDirectionExpression, LeaveDirectionExpression;
 
608
                
 
609
                void IAstVisitor.VisitDirectionExpression(DirectionExpression directionExpression)
 
610
                {
 
611
                        Visit(EnterDirectionExpression, LeaveDirectionExpression, directionExpression);
 
612
                }
 
613
                
 
614
                public event Action<MemberReferenceExpression> EnterMemberReferenceExpression, LeaveMemberReferenceExpression;
 
615
                
 
616
                void IAstVisitor.VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression)
 
617
                {
 
618
                        Visit(EnterMemberReferenceExpression, LeaveMemberReferenceExpression, memberReferenceExpression);
 
619
                }
 
620
                
 
621
                public event Action<NullReferenceExpression> EnterNullReferenceExpression, LeaveNullReferenceExpression;
 
622
                
 
623
                void IAstVisitor.VisitNullReferenceExpression(NullReferenceExpression nullReferenceExpression)
 
624
                {
 
625
                        Visit(EnterNullReferenceExpression, LeaveNullReferenceExpression, nullReferenceExpression);
 
626
                }
 
627
                
 
628
                public event Action<ObjectCreateExpression> EnterObjectCreateExpression, LeaveObjectCreateExpression;
 
629
                
 
630
                void IAstVisitor.VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression)
 
631
                {
 
632
                        Visit(EnterObjectCreateExpression, LeaveObjectCreateExpression, objectCreateExpression);
 
633
                }
 
634
                
 
635
                public event Action<AnonymousTypeCreateExpression> EnterAnonymousTypeCreateExpression, LeaveAnonymousTypeCreateExpression;
 
636
                
 
637
                void IAstVisitor.VisitAnonymousTypeCreateExpression(AnonymousTypeCreateExpression anonymousTypeCreateExpression)
 
638
                {
 
639
                        Visit(EnterAnonymousTypeCreateExpression, LeaveAnonymousTypeCreateExpression, anonymousTypeCreateExpression);
 
640
                }
 
641
                
 
642
                public event Action<ArrayCreateExpression> EnterArrayCreateExpression, LeaveArrayCreateExpression;
 
643
                
 
644
                void IAstVisitor.VisitArrayCreateExpression(ArrayCreateExpression arraySCreateExpression)
 
645
                {
 
646
                        Visit(EnterArrayCreateExpression, LeaveArrayCreateExpression, arraySCreateExpression);
 
647
                }
 
648
                
 
649
                public event Action<ParenthesizedExpression> EnterParenthesizedExpression, LeaveParenthesizedExpression;
 
650
                
 
651
                void IAstVisitor.VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression)
 
652
                {
 
653
                        Visit(EnterParenthesizedExpression, LeaveParenthesizedExpression, parenthesizedExpression);
 
654
                }
 
655
                
 
656
                public event Action<PointerReferenceExpression> EnterPointerReferenceExpression, LeavePointerReferenceExpression;
 
657
                
 
658
                void IAstVisitor.VisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression)
 
659
                {
 
660
                        Visit(EnterPointerReferenceExpression, LeavePointerReferenceExpression, pointerReferenceExpression);
 
661
                }
 
662
                
 
663
                public event Action<PrimitiveExpression> EnterPrimitiveExpression, LeavePrimitiveExpression;
 
664
                
 
665
                void IAstVisitor.VisitPrimitiveExpression(PrimitiveExpression primitiveExpression)
 
666
                {
 
667
                        Visit(EnterPrimitiveExpression, LeavePrimitiveExpression, primitiveExpression);
 
668
                }
 
669
                
 
670
                public event Action<SizeOfExpression> EnterSizeOfExpression, LeaveSizeOfExpression;
 
671
                
 
672
                void IAstVisitor.VisitSizeOfExpression(SizeOfExpression sizeOfExpression)
 
673
                {
 
674
                        Visit(EnterSizeOfExpression, LeaveSizeOfExpression, sizeOfExpression);
 
675
                }
 
676
                
 
677
                public event Action<StackAllocExpression> EnterStackAllocExpression, LeaveStackAllocExpression;
 
678
                
 
679
                void IAstVisitor.VisitStackAllocExpression(StackAllocExpression stackAllocExpression)
 
680
                {
 
681
                        Visit(EnterStackAllocExpression, LeaveStackAllocExpression, stackAllocExpression);
 
682
                }
 
683
                
 
684
                public event Action<ThisReferenceExpression> EnterThisReferenceExpression, LeaveThisReferenceExpression;
 
685
                
 
686
                void IAstVisitor.VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression)
 
687
                {
 
688
                        Visit(EnterThisReferenceExpression, LeaveThisReferenceExpression, thisReferenceExpression);
 
689
                }
 
690
                
 
691
                public event Action<TypeOfExpression> EnterTypeOfExpression, LeaveTypeOfExpression;
 
692
                
 
693
                void IAstVisitor.VisitTypeOfExpression(TypeOfExpression typeOfExpression)
 
694
                {
 
695
                        Visit(EnterTypeOfExpression, LeaveTypeOfExpression, typeOfExpression);
 
696
                }
 
697
                
 
698
                public event Action<TypeReferenceExpression> EnterTypeReferenceExpression, LeaveTypeReferenceExpression;
 
699
                
 
700
                void IAstVisitor.VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression)
 
701
                {
 
702
                        Visit(EnterTypeReferenceExpression, LeaveTypeReferenceExpression, typeReferenceExpression);
 
703
                }
 
704
                
 
705
                public event Action<UnaryOperatorExpression> EnterUnaryOperatorExpression, LeaveUnaryOperatorExpression;
 
706
                
 
707
                void IAstVisitor.VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression)
 
708
                {
 
709
                        Visit(EnterUnaryOperatorExpression, LeaveUnaryOperatorExpression, unaryOperatorExpression);
 
710
                }
 
711
                
 
712
                public event Action<UncheckedExpression> EnterUncheckedExpression, LeaveUncheckedExpression;
 
713
                
 
714
                void IAstVisitor.VisitUncheckedExpression(UncheckedExpression uncheckedExpression)
 
715
                {
 
716
                        Visit(EnterUncheckedExpression, LeaveUncheckedExpression, uncheckedExpression);
 
717
                }
 
718
                
 
719
                public event Action<QueryExpression> EnterQueryExpression, LeaveQueryExpression;
 
720
                
 
721
                void IAstVisitor.VisitQueryExpression(QueryExpression queryExpression)
 
722
                {
 
723
                        Visit(EnterQueryExpression, LeaveQueryExpression, queryExpression);
 
724
                }
 
725
                
 
726
                public event Action<QueryContinuationClause> EnterQueryContinuationClause, LeaveQueryContinuationClause;
 
727
                
 
728
                void IAstVisitor.VisitQueryContinuationClause(QueryContinuationClause queryContinuationClause)
 
729
                {
 
730
                        Visit(EnterQueryContinuationClause, LeaveQueryContinuationClause, queryContinuationClause);
 
731
                }
 
732
                
 
733
                public event Action<QueryFromClause> EnterQueryFromClause, LeaveQueryFromClause;
 
734
                
 
735
                void IAstVisitor.VisitQueryFromClause(QueryFromClause queryFromClause)
 
736
                {
 
737
                        Visit(EnterQueryFromClause, LeaveQueryFromClause, queryFromClause);
 
738
                }
 
739
                
 
740
                public event Action<QueryLetClause> EnterQueryLetClause, LeaveQueryLetClause;
 
741
                
 
742
                void IAstVisitor.VisitQueryLetClause(QueryLetClause queryLetClause)
 
743
                {
 
744
                        Visit(EnterQueryLetClause, LeaveQueryLetClause, queryLetClause);
 
745
                }
 
746
                
 
747
                public event Action<QueryWhereClause> EnterQueryWhereClause, LeaveQueryWhereClause;
 
748
                
 
749
                void IAstVisitor.VisitQueryWhereClause(QueryWhereClause queryWhereClause)
 
750
                {
 
751
                        Visit(EnterQueryWhereClause, LeaveQueryWhereClause, queryWhereClause);
 
752
                }
 
753
                
 
754
                public event Action<QueryJoinClause> EnterQueryJoinClause, LeaveQueryJoinClause;
 
755
                
 
756
                void IAstVisitor.VisitQueryJoinClause(QueryJoinClause queryJoinClause)
 
757
                {
 
758
                        Visit(EnterQueryJoinClause, LeaveQueryJoinClause, queryJoinClause);
 
759
                }
 
760
                
 
761
                public event Action<QueryOrderClause> EnterQueryOrderClause, LeaveQueryOrderClause;
 
762
                
 
763
                void IAstVisitor.VisitQueryOrderClause(QueryOrderClause queryOrderClause)
 
764
                {
 
765
                        Visit(EnterQueryOrderClause, LeaveQueryOrderClause, queryOrderClause);
 
766
                }
 
767
                
 
768
                public event Action<QueryOrdering> EnterQueryOrdering, LeaveQueryOrdering;
 
769
                
 
770
                void IAstVisitor.VisitQueryOrdering(QueryOrdering queryOrdering)
 
771
                {
 
772
                        Visit(EnterQueryOrdering, LeaveQueryOrdering, queryOrdering);
 
773
                }
 
774
                
 
775
                public event Action<QuerySelectClause> EnterQuerySelectClause, LeaveQuerySelectClause;
 
776
                
 
777
                void IAstVisitor.VisitQuerySelectClause(QuerySelectClause querySelectClause)
 
778
                {
 
779
                        Visit(EnterQuerySelectClause, LeaveQuerySelectClause, querySelectClause);
 
780
                }
 
781
                
 
782
                public event Action<QueryGroupClause> EnterQueryGroupClause, LeaveQueryGroupClause;
 
783
                
 
784
                void IAstVisitor.VisitQueryGroupClause(QueryGroupClause queryGroupClause)
 
785
                {
 
786
                        Visit(EnterQueryGroupClause, LeaveQueryGroupClause, queryGroupClause);
 
787
                }
 
788
                
 
789
                public event Action<AsExpression> EnterAsExpression, LeaveAsExpression;
 
790
                
 
791
                void IAstVisitor.VisitAsExpression(AsExpression asExpression)
 
792
                {
 
793
                        Visit(EnterAsExpression, LeaveAsExpression, asExpression);
 
794
                }
 
795
                
 
796
                public event Action<IsExpression> EnterIsExpression, LeaveIsExpression;
 
797
                
 
798
                void IAstVisitor.VisitIsExpression(IsExpression isExpression)
 
799
                {
 
800
                        Visit(EnterIsExpression, LeaveIsExpression, isExpression);
 
801
                }
 
802
                
 
803
                public event Action<DefaultValueExpression> EnterDefaultValueExpression, LeaveDefaultValueExpression;
 
804
                
 
805
                void IAstVisitor.VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
 
806
                {
 
807
                        Visit(EnterDefaultValueExpression, LeaveDefaultValueExpression, defaultValueExpression);
 
808
                }
 
809
                
 
810
                public event Action<UndocumentedExpression> EnterUndocumentedExpression, LeaveUndocumentedExpression;
 
811
                
 
812
                void IAstVisitor.VisitUndocumentedExpression(UndocumentedExpression undocumentedExpression)
 
813
                {
 
814
                        Visit(EnterUndocumentedExpression, LeaveUndocumentedExpression, undocumentedExpression);
 
815
                }
 
816
                
 
817
                public event Action<ArrayInitializerExpression> EnterArrayInitializerExpression, LeaveArrayInitializerExpression;
 
818
                
 
819
                void IAstVisitor.VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression)
 
820
                {
 
821
                        Visit(EnterArrayInitializerExpression, LeaveArrayInitializerExpression, arrayInitializerExpression);
 
822
                }
 
823
                
 
824
                public event Action<ArraySpecifier> EnterArraySpecifier, LeaveArraySpecifier;
 
825
                
 
826
                void IAstVisitor.VisitArraySpecifier(ArraySpecifier arraySpecifier)
 
827
                {
 
828
                        Visit(EnterArraySpecifier, LeaveArraySpecifier, arraySpecifier);
 
829
                }
 
830
                
 
831
                public event Action<NamedArgumentExpression> EnterNamedArgumentExpression, LeaveNamedArgumentExpression;
 
832
                
 
833
                void IAstVisitor.VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression)
 
834
                {
 
835
                        Visit(EnterNamedArgumentExpression, LeaveNamedArgumentExpression, namedArgumentExpression);
 
836
                }
 
837
                
 
838
                public event Action<NamedExpression> EnterNamedExpression, LeaveNamedExpression;
 
839
                
 
840
                void IAstVisitor.VisitNamedExpression(NamedExpression namedExpression)
 
841
                {
 
842
                        Visit(EnterNamedExpression, LeaveNamedExpression, namedExpression);
 
843
                }
 
844
                
 
845
                public event Action<EmptyExpression> EnterEmptyExpression, LeaveEmptyExpression;
 
846
                
 
847
                void IAstVisitor.VisitEmptyExpression(EmptyExpression emptyExpression)
 
848
                {
 
849
                        Visit(EnterEmptyExpression, LeaveEmptyExpression, emptyExpression);
 
850
                }
 
851
                
 
852
                void IAstVisitor.VisitPatternPlaceholder(AstNode placeholder, PatternMatching.Pattern pattern)
 
853
                {
 
854
                }
 
855
        }
 
856
}