← 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/Refactoring/VariableReferenceGraph.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/Refactoring/VariableReferenceGraph.cs
 
1
ļ»æ// 
 
2
// VariableReferenceGraph.cs
 
3
// 
 
4
// Author:
 
5
//      Mansheng Yang <lightyang0@gmail.com>
 
6
// 
 
7
// Copyright (c) 2012 Mansheng Yang <lightyang0@gmail.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.Collections.Generic;
 
28
using System.Linq;
 
29
using ICSharpCode.NRefactory.CSharp.Analysis;
 
30
using ICSharpCode.NRefactory.CSharp.Resolver;
 
31
using System.Threading;
 
32
 
 
33
namespace ICSharpCode.NRefactory.CSharp.Refactoring
 
34
{
 
35
        class VariableReferenceNode
 
36
        {
 
37
                public IList<AstNode> References {
 
38
                        get;
 
39
                        private set;
 
40
                }
 
41
 
 
42
                public IList<VariableReferenceNode> NextNodes {
 
43
                        get;
 
44
                        private set;
 
45
                }
 
46
 
 
47
                public IList<VariableReferenceNode> PreviousNodes {
 
48
                        get;
 
49
                        private set;
 
50
                }
 
51
 
 
52
                public VariableReferenceNode ()
 
53
                {
 
54
                        References = new List<AstNode> ();
 
55
                        NextNodes = new List<VariableReferenceNode> ();
 
56
                        PreviousNodes = new List<VariableReferenceNode> ();
 
57
                }
 
58
 
 
59
                public void AddNextNode (VariableReferenceNode node)
 
60
                {
 
61
                        NextNodes.Add (node);
 
62
                        node.PreviousNodes.Add (this);
 
63
                }
 
64
        }
 
65
 
 
66
        class VariableReferenceGraphBuilder
 
67
        {
 
68
                ControlFlowGraphBuilder cfgBuilder = new ControlFlowGraphBuilder ();
 
69
                CfgVariableReferenceNodeBuilder cfgVrNodeBuilder;
 
70
                BaseRefactoringContext ctx;
 
71
 
 
72
                public VariableReferenceGraphBuilder(BaseRefactoringContext ctx)
 
73
                {
 
74
                        this.ctx = ctx;
 
75
                        cfgVrNodeBuilder = new CfgVariableReferenceNodeBuilder (this);
 
76
                }
 
77
 
 
78
                public VariableReferenceNode Build (ISet<AstNode> references, CSharpAstResolver resolver,
 
79
                        Expression expression)
 
80
                {
 
81
                        return ExpressionNodeCreationVisitor.CreateNode (references, resolver, new [] { expression });
 
82
                }
 
83
 
 
84
                public VariableReferenceNode Build (Statement statement, ISet<AstNode> references,
 
85
                        ISet<Statement> refStatements, BaseRefactoringContext context)
 
86
                {
 
87
                        var cfg = cfgBuilder.BuildControlFlowGraph (statement, context.Resolver, context.CancellationToken);
 
88
                        if (cfg.Count == 0)
 
89
                                return new VariableReferenceNode ();
 
90
                        return cfgVrNodeBuilder.Build (cfg [0], references, refStatements, context.Resolver);
 
91
                }
 
92
 
 
93
                public VariableReferenceNode Build (Statement statement, ISet<AstNode> references,
 
94
                                                           ISet<Statement> refStatements, CSharpAstResolver resolver, CancellationToken cancellationToken = default(CancellationToken))
 
95
                {
 
96
                        var cfg = cfgBuilder.BuildControlFlowGraph (statement, resolver, cancellationToken);
 
97
                        if (cfg.Count == 0)
 
98
                                return new VariableReferenceNode();
 
99
                        return cfgVrNodeBuilder.Build (cfg [0], references, refStatements, resolver);
 
100
                }
 
101
 
 
102
                class GetExpressionsVisitor : DepthFirstAstVisitor<IEnumerable<Expression>>
 
103
                {
 
104
 
 
105
                        public override IEnumerable<Expression> VisitIfElseStatement (IfElseStatement ifElseStatement)
 
106
                        {
 
107
                                yield return ifElseStatement.Condition;
 
108
                        }
 
109
 
 
110
                        public override IEnumerable<Expression> VisitSwitchStatement (SwitchStatement switchStatement)
 
111
                        {
 
112
                                yield return switchStatement.Expression;
 
113
                        }
 
114
 
 
115
                        public override IEnumerable<Expression> VisitForStatement (ForStatement forStatement)
 
116
                        {
 
117
                                yield return forStatement.Condition;
 
118
                        }
 
119
 
 
120
                        public override IEnumerable<Expression> VisitDoWhileStatement (DoWhileStatement doWhileStatement)
 
121
                        {
 
122
                                yield return doWhileStatement.Condition;
 
123
                        }
 
124
 
 
125
                        public override IEnumerable<Expression> VisitWhileStatement (WhileStatement whileStatement)
 
126
                        {
 
127
                                yield return whileStatement.Condition;
 
128
                        }
 
129
 
 
130
                        public override IEnumerable<Expression> VisitForeachStatement (ForeachStatement foreachStatement)
 
131
                        {
 
132
                                yield return foreachStatement.InExpression;
 
133
                        }
 
134
 
 
135
                        public override IEnumerable<Expression> VisitExpressionStatement (ExpressionStatement expressionStatement)
 
136
                        {
 
137
                                yield return expressionStatement.Expression;
 
138
                        }
 
139
 
 
140
                        public override IEnumerable<Expression> VisitLockStatement (LockStatement lockStatement)
 
141
                        {
 
142
                                yield return lockStatement.Expression;
 
143
                        }
 
144
 
 
145
                        public override IEnumerable<Expression> VisitReturnStatement (ReturnStatement returnStatement)
 
146
                        {
 
147
                                yield return returnStatement.Expression;
 
148
                        }
 
149
 
 
150
                        public override IEnumerable<Expression> VisitThrowStatement (ThrowStatement throwStatement)
 
151
                        {
 
152
                                yield return throwStatement.Expression;
 
153
                        }
 
154
 
 
155
                        public override IEnumerable<Expression> VisitUsingStatement (UsingStatement usingStatement)
 
156
                        {
 
157
                                var expr = usingStatement.ResourceAcquisition as Expression;
 
158
                                if (expr != null)
 
159
                                        return new [] { expr };
 
160
 
 
161
                                return usingStatement.ResourceAcquisition.AcceptVisitor (this);
 
162
                        }
 
163
 
 
164
                        public override IEnumerable<Expression> VisitVariableDeclarationStatement (
 
165
                                VariableDeclarationStatement variableDeclarationStatement)
 
166
                        {
 
167
                                return variableDeclarationStatement.Variables.Select (v => v.Initializer);
 
168
                        }
 
169
 
 
170
                        public override IEnumerable<Expression> VisitYieldReturnStatement (YieldReturnStatement yieldReturnStatement)
 
171
                        {
 
172
                                yield return yieldReturnStatement.Expression;
 
173
                        }
 
174
 
 
175
                        public override IEnumerable<Expression> VisitBlockStatement(BlockStatement blockStatement)
 
176
                        {
 
177
                                yield break;
 
178
                        }
 
179
                }
 
180
 
 
181
                class CfgVariableReferenceNodeBuilder
 
182
                {
 
183
                        readonly VariableReferenceGraphBuilder variableReferenceGraphBuilder;
 
184
                        GetExpressionsVisitor getExpr = new GetExpressionsVisitor ();
 
185
 
 
186
                        ISet<AstNode> references;
 
187
                        ISet<Statement> refStatements;
 
188
                        CSharpAstResolver resolver;
 
189
                        Dictionary<ControlFlowNode, VariableReferenceNode> nodeDict;
 
190
 
 
191
                        public CfgVariableReferenceNodeBuilder(VariableReferenceGraphBuilder variableReferenceGraphBuilder)
 
192
                        {
 
193
                                this.variableReferenceGraphBuilder = variableReferenceGraphBuilder;
 
194
                        }
 
195
 
 
196
                        public VariableReferenceNode Build (ControlFlowNode startNode, ISet<AstNode> references,
 
197
                                ISet<Statement> refStatements, CSharpAstResolver resolver)
 
198
                        {
 
199
                                this.references = references;
 
200
                                this.refStatements = refStatements;
 
201
                                this.resolver = resolver;
 
202
                                nodeDict = new Dictionary<ControlFlowNode, VariableReferenceNode> ();
 
203
                                return AddNode (startNode);
 
204
                        }
 
205
 
 
206
                        static bool IsValidControlFlowNode (ControlFlowNode node)
 
207
                        {
 
208
                                if (node.NextStatement == null)
 
209
                                        return false;
 
210
                                if (node.Type == ControlFlowNodeType.LoopCondition) {
 
211
                                        if (node.NextStatement is ForeachStatement)
 
212
                                                return false;
 
213
                                } else {
 
214
                                        if (node.NextStatement is WhileStatement || node.NextStatement is DoWhileStatement ||
 
215
                                                node.NextStatement is ForStatement)
 
216
                                                return false;
 
217
                                }
 
218
                                return true;
 
219
                        }
 
220
 
 
221
                        VariableReferenceNode GetStatementEndNode (VariableReferenceNode currentNode, Statement statement)
 
222
                        {
 
223
                                var expressions = statement.AcceptVisitor (getExpr);
 
224
                                VariableReferenceNode endNode;
 
225
                                ExpressionNodeCreationVisitor.CreateNode (references, resolver, expressions, currentNode, out endNode);
 
226
                                return endNode;
 
227
                        }
 
228
 
 
229
                        VariableReferenceNode AddNode (ControlFlowNode startNode)
 
230
                        {
 
231
                                var node = new VariableReferenceNode ();
 
232
                                var cfNode = startNode;
 
233
                                while (true) {
 
234
                                        if (variableReferenceGraphBuilder.ctx.CancellationToken.IsCancellationRequested)
 
235
                                                return null;
 
236
                                        if (nodeDict.ContainsKey (cfNode)) {
 
237
                                                node.AddNextNode (nodeDict [cfNode]);
 
238
                                                break;
 
239
                                        }
 
240
                                        // create a new node for fork point
 
241
                                        if (cfNode.Incoming.Count > 1 || cfNode.Outgoing.Count > 1) {
 
242
                                                nodeDict [cfNode] = node;
 
243
 
 
244
                                                var forkNode = new VariableReferenceNode ();
 
245
                                                node.AddNextNode (forkNode);
 
246
                                                node = forkNode;
 
247
                                        }
 
248
                                        nodeDict [cfNode] = node;
 
249
 
 
250
                                        if (IsValidControlFlowNode (cfNode) && refStatements.Contains (cfNode.NextStatement)) {
 
251
                                                node = GetStatementEndNode (node, cfNode.NextStatement);
 
252
                                        }
 
253
 
 
254
                                        if (cfNode.Outgoing.Count == 1) {
 
255
                                                cfNode = cfNode.Outgoing [0].To;
 
256
                                        } else {
 
257
                                                foreach (var e in cfNode.Outgoing) {
 
258
                                                        node.AddNextNode (AddNode (e.To));
 
259
                                                }
 
260
                                                break;
 
261
                                        }
 
262
                                }
 
263
                                VariableReferenceNode result;
 
264
                                if (!nodeDict.TryGetValue (startNode, out result))
 
265
                                        return new VariableReferenceNode ();
 
266
                                return result;
 
267
                        }
 
268
                }
 
269
 
 
270
                class ExpressionNodeCreationVisitor : DepthFirstAstVisitor
 
271
                {
 
272
                        VariableReferenceNode startNode;
 
273
                        VariableReferenceNode endNode;
 
274
                        ISet<AstNode> references;
 
275
                        CSharpAstResolver resolver;
 
276
 
 
277
                        ExpressionNodeCreationVisitor (ISet<AstNode> references, CSharpAstResolver resolver,
 
278
                                VariableReferenceNode startNode)
 
279
                        {
 
280
                                this.references = references;
 
281
                                this.resolver = resolver;
 
282
                                this.startNode = this.endNode = startNode ?? new VariableReferenceNode ();
 
283
                        }
 
284
 
 
285
                        public static VariableReferenceNode CreateNode (ISet<AstNode> references, CSharpAstResolver resolver,
 
286
                                params Expression [] expressions)
 
287
                        {
 
288
                                VariableReferenceNode endNode;
 
289
                                return CreateNode (references, resolver, expressions, null, out endNode);
 
290
                        }
 
291
 
 
292
                        public static VariableReferenceNode CreateNode (ISet<AstNode> references, CSharpAstResolver resolver,
 
293
                                IEnumerable<Expression> expressions, VariableReferenceNode startNode, out VariableReferenceNode endNode)
 
294
                        {
 
295
                                startNode = startNode ?? new VariableReferenceNode ();
 
296
                                endNode = startNode;
 
297
                                foreach (var expr in expressions) {
 
298
                                        var visitor = CreateVisitor (references, resolver, expr, endNode);
 
299
                                        endNode = visitor.endNode;
 
300
                                }
 
301
                                return startNode;
 
302
                        }
 
303
 
 
304
                        static ExpressionNodeCreationVisitor CreateVisitor (ISet<AstNode> references, CSharpAstResolver resolver,
 
305
                                Expression rootExpr, VariableReferenceNode startNode = null, VariableReferenceNode nextNode = null)
 
306
                        {
 
307
                                var visitor = new ExpressionNodeCreationVisitor (references, resolver, startNode);
 
308
                                rootExpr.AcceptVisitor (visitor);
 
309
                                if (nextNode != null)
 
310
                                        visitor.endNode.AddNextNode (nextNode);
 
311
                                return visitor;
 
312
                        }
 
313
 
 
314
                        static VariableReferenceNode CreateNode (ISet<AstNode> references, CSharpAstResolver resolver, 
 
315
                                Expression rootExpr, VariableReferenceNode startNode = null, VariableReferenceNode nextNode = null)
 
316
                        {
 
317
                                return CreateVisitor (references, resolver, rootExpr, startNode, nextNode).startNode;
 
318
                        }
 
319
 
 
320
                        #region Skipped Expressions
 
321
                        public override void VisitAnonymousMethodExpression (AnonymousMethodExpression anonymousMethodExpression)
 
322
                        {
 
323
                        }
 
324
 
 
325
                        public override void VisitLambdaExpression (LambdaExpression lambdaExpression)
 
326
                        {
 
327
                        }
 
328
 
 
329
                        public override void VisitBaseReferenceExpression (BaseReferenceExpression baseReferenceExpression)
 
330
                        {
 
331
                        }
 
332
 
 
333
                        public override void VisitNullReferenceExpression (NullReferenceExpression nullReferenceExpression)
 
334
                        {
 
335
                        }
 
336
 
 
337
                        public override void VisitPrimitiveExpression (PrimitiveExpression primitiveExpression)
 
338
                        {
 
339
                        }
 
340
 
 
341
                        public override void VisitSizeOfExpression (SizeOfExpression sizeOfExpression)
 
342
                        {
 
343
                        }
 
344
 
 
345
                        public override void VisitThisReferenceExpression (ThisReferenceExpression thisReferenceExpression)
 
346
                        {
 
347
                        }
 
348
 
 
349
                        public override void VisitTypeOfExpression (TypeOfExpression typeOfExpression)
 
350
                        {
 
351
                        }
 
352
 
 
353
                        public override void VisitTypeReferenceExpression (TypeReferenceExpression typeReferenceExpression)
 
354
                        {
 
355
                        }
 
356
 
 
357
                        public override void VisitUndocumentedExpression (UndocumentedExpression undocumentedExpression)
 
358
                        {
 
359
                        }
 
360
 
 
361
                        public override void VisitDefaultValueExpression (DefaultValueExpression defaultValueExpression)
 
362
                        {
 
363
                        }
 
364
 
 
365
                        public override void VisitEmptyExpression (EmptyExpression emptyExpression)
 
366
                        {
 
367
                        }
 
368
 
 
369
                        #endregion
 
370
 
 
371
                        public override void VisitAssignmentExpression (AssignmentExpression assignmentExpression)
 
372
                        {
 
373
                                assignmentExpression.Right.AcceptVisitor (this);
 
374
                                assignmentExpression.Left.AcceptVisitor (this);
 
375
                        }
 
376
 
 
377
                        public override void VisitBinaryOperatorExpression (BinaryOperatorExpression binaryOperatorExpression)
 
378
                        {
 
379
                                binaryOperatorExpression.Left.AcceptVisitor (this);
 
380
                                binaryOperatorExpression.Right.AcceptVisitor (this);
 
381
                        }
 
382
 
 
383
                        public override void VisitCastExpression (CastExpression castExpression)
 
384
                        {
 
385
                                castExpression.Expression.AcceptVisitor (this);
 
386
                        }
 
387
 
 
388
                        public override void VisitCheckedExpression (CheckedExpression checkedExpression)
 
389
                        {
 
390
                                checkedExpression.Expression.AcceptVisitor (this);
 
391
                        }
 
392
 
 
393
                        public override void VisitConditionalExpression (ConditionalExpression conditionalExpression)
 
394
                        {
 
395
                                conditionalExpression.Condition.AcceptVisitor (this);
 
396
                                var resolveResult = resolver.Resolve (conditionalExpression.Condition);
 
397
                                if (resolveResult.ConstantValue is bool) {
 
398
                                        if ((bool) resolveResult.ConstantValue)
 
399
                                                conditionalExpression.TrueExpression.AcceptVisitor (this);
 
400
                                        else
 
401
                                                conditionalExpression.FalseExpression.AcceptVisitor (this);
 
402
                                        return;
 
403
                                }
 
404
                                var nextEndNode = new VariableReferenceNode ();
 
405
                                var trueNode = CreateNode (references, resolver, conditionalExpression.TrueExpression, null, 
 
406
                                        nextEndNode);
 
407
                                var falseNode = CreateNode (references, resolver, conditionalExpression.FalseExpression, null, 
 
408
                                        nextEndNode);
 
409
                                endNode.AddNextNode (trueNode);
 
410
                                endNode.AddNextNode (falseNode);
 
411
                                endNode = nextEndNode;
 
412
                        }
 
413
 
 
414
                        public override void VisitIdentifierExpression (IdentifierExpression identifierExpression)
 
415
                        {
 
416
                                if (references.Contains (identifierExpression))
 
417
                                        endNode.References.Add (identifierExpression);
 
418
                        }
 
419
 
 
420
                        public override void VisitIndexerExpression (IndexerExpression indexerExpression)
 
421
                        {
 
422
                                indexerExpression.Target.AcceptVisitor (this);
 
423
                                foreach (var arg in indexerExpression.Arguments)
 
424
                                        arg.AcceptVisitor (this);
 
425
                        }
 
426
 
 
427
                        public override void VisitInvocationExpression (InvocationExpression invocationExpression)
 
428
                        {
 
429
                                invocationExpression.Target.AcceptVisitor (this);
 
430
                                var outArguments = new List<Expression> ();
 
431
                                foreach (var arg in invocationExpression.Arguments) {
 
432
                                        var directionExpr = arg as DirectionExpression;
 
433
                                        if (directionExpr != null && directionExpr.FieldDirection == FieldDirection.Out) {
 
434
                                                outArguments.Add (directionExpr);
 
435
                                                continue;
 
436
                                        }
 
437
                                        arg.AcceptVisitor (this);
 
438
                                }
 
439
                                foreach (var arg in outArguments)
 
440
                                        arg.AcceptVisitor (this);
 
441
                        }
 
442
 
 
443
                        public override void VisitDirectionExpression (DirectionExpression directionExpression)
 
444
                        {
 
445
                                directionExpression.Expression.AcceptVisitor (this);
 
446
                        }
 
447
 
 
448
                        public override void VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression)
 
449
                        {
 
450
                                memberReferenceExpression.Target.AcceptVisitor (this);
 
451
                        }
 
452
 
 
453
                        public override void VisitObjectCreateExpression (ObjectCreateExpression objectCreateExpression)
 
454
                        {
 
455
                                foreach (var arg in objectCreateExpression.Arguments)
 
456
                                        arg.AcceptVisitor (this);
 
457
                                objectCreateExpression.Initializer.AcceptVisitor (this);
 
458
                        }
 
459
 
 
460
                        public override void VisitAnonymousTypeCreateExpression (
 
461
                                AnonymousTypeCreateExpression anonymousTypeCreateExpression)
 
462
                        {
 
463
                                foreach (var init in anonymousTypeCreateExpression.Initializers)
 
464
                                        init.AcceptVisitor (this);
 
465
                        }
 
466
 
 
467
                        public override void VisitArrayCreateExpression (ArrayCreateExpression arrayCreateExpression)
 
468
                        {
 
469
                                foreach (var arg in arrayCreateExpression.Arguments)
 
470
                                        arg.AcceptVisitor (this);
 
471
                                arrayCreateExpression.Initializer.AcceptVisitor (this);
 
472
                        }
 
473
 
 
474
                        public override void VisitParenthesizedExpression (ParenthesizedExpression parenthesizedExpression)
 
475
                        {
 
476
                                parenthesizedExpression.Expression.AcceptVisitor (this);
 
477
                        }
 
478
 
 
479
                        public override void VisitPointerReferenceExpression (PointerReferenceExpression pointerReferenceExpression)
 
480
                        {
 
481
                                pointerReferenceExpression.Target.AcceptVisitor (this);
 
482
                        }
 
483
 
 
484
                        public override void VisitStackAllocExpression (StackAllocExpression stackAllocExpression)
 
485
                        {
 
486
                                stackAllocExpression.CountExpression.AcceptVisitor (this);
 
487
                        }
 
488
 
 
489
                        public override void VisitUnaryOperatorExpression (UnaryOperatorExpression unaryOperatorExpression)
 
490
                        {
 
491
                                unaryOperatorExpression.Expression.AcceptVisitor (this);
 
492
                        }
 
493
 
 
494
                        public override void VisitUncheckedExpression (UncheckedExpression uncheckedExpression)
 
495
                        {
 
496
                                uncheckedExpression.Expression.AcceptVisitor (this);
 
497
                        }
 
498
 
 
499
                        public override void VisitAsExpression (AsExpression asExpression)
 
500
                        {
 
501
                                asExpression.Expression.AcceptVisitor (this);
 
502
                        }
 
503
 
 
504
                        public override void VisitIsExpression (IsExpression isExpression)
 
505
                        {
 
506
                                isExpression.Expression.AcceptVisitor (this);
 
507
                        }
 
508
 
 
509
                        public override void VisitArrayInitializerExpression (ArrayInitializerExpression arrayInitializerExpression)
 
510
                        {
 
511
                                foreach (var element in arrayInitializerExpression.Elements)
 
512
                                        element.AcceptVisitor (this);
 
513
                        }
 
514
 
 
515
                        public override void VisitNamedArgumentExpression (NamedArgumentExpression namedArgumentExpression)
 
516
                        {
 
517
                                namedArgumentExpression.Expression.AcceptVisitor (this);
 
518
                        }
 
519
 
 
520
                        public override void VisitNamedExpression (NamedExpression namedExpression)
 
521
                        {
 
522
                                namedExpression.Expression.AcceptVisitor (this);
 
523
                        }
 
524
 
 
525
                        public override void VisitQueryExpression (QueryExpression queryExpression)
 
526
                        {
 
527
                                foreach (var clause in queryExpression.Clauses)
 
528
                                        clause.AcceptVisitor (this);
 
529
                        }
 
530
 
 
531
                        #region Query Clauses
 
532
 
 
533
                        public override void VisitQueryContinuationClause (QueryContinuationClause queryContinuationClause)
 
534
                        {
 
535
                                queryContinuationClause.PrecedingQuery.AcceptVisitor (this);
 
536
                        }
 
537
 
 
538
                        public override void VisitQueryFromClause (QueryFromClause queryFromClause)
 
539
                        {
 
540
                                queryFromClause.Expression.AcceptVisitor (this);
 
541
                        }
 
542
 
 
543
                        public override void VisitQueryJoinClause (QueryJoinClause queryJoinClause)
 
544
                        {
 
545
                                queryJoinClause.InExpression.AcceptVisitor (this);
 
546
                        }
 
547
 
 
548
                        public override void VisitQueryLetClause (QueryLetClause queryLetClause)
 
549
                        {
 
550
                        }
 
551
 
 
552
                        public override void VisitQueryWhereClause (QueryWhereClause queryWhereClause)
 
553
                        {
 
554
                        }
 
555
 
 
556
                        public override void VisitQueryOrderClause (QueryOrderClause queryOrderClause)
 
557
                        {
 
558
                        }
 
559
 
 
560
                        public override void VisitQueryOrdering (QueryOrdering queryOrdering)
 
561
                        {
 
562
                        }
 
563
 
 
564
                        public override void VisitQuerySelectClause (QuerySelectClause querySelectClause)
 
565
                        {
 
566
                        }
 
567
 
 
568
                        public override void VisitQueryGroupClause (QueryGroupClause queryGroupClause)
 
569
                        {
 
570
                        }
 
571
 
 
572
                        #endregion
 
573
                }
 
574
        }
 
575
}
 
 
b'\\ No newline at end of file'