source: tags/3.3.13/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Ast/DepthFirstAstVisitor.cs @ 13320

// 
// IAstVisitor.cs
//
// Author:
//       Mike Krüger <mkrueger@novell.com>
// 
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

using System;

namespace ICSharpCode.NRefactory.CSharp
{
  /// <summary>
  /// AST visitor with a default implementation that visits all node depth-first.
  /// </summary>
  public abstract class DepthFirstAstVisitor : IAstVisitor
  {
    protected virtual void VisitChildren (AstNode node)
    {
      AstNode next;
      for (var child = node.FirstChild; child != null; child = next) {
        // Store next to allow the loop to continue
        // if the visitor removes/replaces child.
        next = child.NextSibling;
        child.AcceptVisitor (this);
      }
    }
    
    public virtual void VisitNullNode(AstNode nullNode)
    {
      // Should we call VisitChildren here?
      // We usually want to ignore null nodes.
      // Older NR versions (before VisitNullNode was introduced) didn't call VisitChildren() with null nodes;
      // so changing this might break VisitChildren() overrides that expect the node to be part of the AST.
    }
    
    public virtual void VisitSyntaxTree (SyntaxTree syntaxTree)
    {
      VisitChildren (syntaxTree);
    }
    
    public virtual void VisitComment(Comment comment)
    {
      VisitChildren(comment);
    }

    public virtual void VisitNewLine(NewLineNode newLineNode)
    {
      VisitChildren(newLineNode);
    }

    public virtual void VisitWhitespace(WhitespaceNode whitespaceNode)
    {
      VisitChildren(whitespaceNode);
    }

    public virtual void VisitText(TextNode textNode)
    {
      VisitChildren(textNode);
    }

    public virtual void VisitDocumentationReference (DocumentationReference documentationReference)
    {
      VisitChildren (documentationReference);
    }
    
    public virtual void VisitPreProcessorDirective (PreProcessorDirective preProcessorDirective)
    {
      VisitChildren (preProcessorDirective);
    }

    public virtual void VisitIdentifier (Identifier identifier)
    {
      VisitChildren (identifier);
    }
    
    public virtual void VisitCSharpTokenNode (CSharpTokenNode token)
    {
      VisitChildren (token);
    }
    
    public virtual void VisitPrimitiveType (PrimitiveType primitiveType)
    {
      VisitChildren (primitiveType);
    }
    
    public virtual void VisitComposedType (ComposedType composedType)
    {
      VisitChildren (composedType);
    }
    
    public virtual void VisitSimpleType(SimpleType simpleType)
    {
      VisitChildren (simpleType);
    }
    
    public virtual void VisitMemberType(MemberType memberType)
    {
      VisitChildren (memberType);
    }
    
    public virtual void VisitAttribute (Attribute attribute)
    {
      VisitChildren (attribute);
    }
    
    public virtual void VisitAttributeSection (AttributeSection attributeSection)
    {
      VisitChildren (attributeSection);
    }
    
    public virtual void VisitDelegateDeclaration (DelegateDeclaration delegateDeclaration)
    {
      VisitChildren (delegateDeclaration);
    }
    
    public virtual void VisitNamespaceDeclaration (NamespaceDeclaration namespaceDeclaration)
    {
      VisitChildren (namespaceDeclaration);
    }
    
    public virtual void VisitTypeDeclaration (TypeDeclaration typeDeclaration)
    {
      VisitChildren (typeDeclaration);
    }
    
    public virtual void VisitTypeParameterDeclaration (TypeParameterDeclaration typeParameterDeclaration)
    {
      VisitChildren (typeParameterDeclaration);
    }
    
    public virtual void VisitEnumMemberDeclaration (EnumMemberDeclaration enumMemberDeclaration)
    {
      VisitChildren (enumMemberDeclaration);
    }
    
    public virtual void VisitUsingDeclaration (UsingDeclaration usingDeclaration)
    {
      VisitChildren (usingDeclaration);
    }
    
    public virtual void VisitUsingAliasDeclaration (UsingAliasDeclaration usingDeclaration)
    {
      VisitChildren (usingDeclaration);
    }
    
    public virtual void VisitExternAliasDeclaration(ExternAliasDeclaration externAliasDeclaration)
    {
      VisitChildren (externAliasDeclaration);
    }
    
    public virtual void VisitConstructorDeclaration (ConstructorDeclaration constructorDeclaration)
    {
      VisitChildren (constructorDeclaration);
    }
    
    public virtual void VisitConstructorInitializer (ConstructorInitializer constructorInitializer)
    {
      VisitChildren (constructorInitializer);
    }
    
    public virtual void VisitDestructorDeclaration (DestructorDeclaration destructorDeclaration)
    {
      VisitChildren (destructorDeclaration);
    }
    
    public virtual void VisitEventDeclaration (EventDeclaration eventDeclaration)
    {
      VisitChildren (eventDeclaration);
    }
    
    public virtual void VisitCustomEventDeclaration (CustomEventDeclaration eventDeclaration)
    {
      VisitChildren (eventDeclaration);
    }
    
    public virtual void VisitFieldDeclaration (FieldDeclaration fieldDeclaration)
    {
      VisitChildren (fieldDeclaration);
    }
    
    public virtual void VisitFixedFieldDeclaration (FixedFieldDeclaration fixedFieldDeclaration)
    {
      VisitChildren (fixedFieldDeclaration);
    }
    
    public virtual void VisitFixedVariableInitializer (FixedVariableInitializer fixedVariableInitializer)
    {
      VisitChildren (fixedVariableInitializer);
    }
    
    public virtual void VisitIndexerDeclaration (IndexerDeclaration indexerDeclaration)
    {
      VisitChildren (indexerDeclaration);
    }
    
    public virtual void VisitMethodDeclaration (MethodDeclaration methodDeclaration)
    {
      VisitChildren (methodDeclaration);
    }
    
    public virtual void VisitOperatorDeclaration (OperatorDeclaration operatorDeclaration)
    {
      VisitChildren (operatorDeclaration);
    }
    
    public virtual void VisitPropertyDeclaration (PropertyDeclaration propertyDeclaration)
    {
      VisitChildren (propertyDeclaration);
    }
    
    public virtual void VisitAccessor (Accessor accessor)
    {
      VisitChildren (accessor);
    }
    
    public virtual void VisitVariableInitializer (VariableInitializer variableInitializer)
    {
      VisitChildren (variableInitializer);
    }
    
    public virtual void VisitParameterDeclaration (ParameterDeclaration parameterDeclaration)
    {
      VisitChildren (parameterDeclaration);
    }
    
    public virtual void VisitConstraint (Constraint constraint)
    {
      VisitChildren (constraint);
    }
    
    public virtual void VisitBlockStatement (BlockStatement blockStatement)
    {
      VisitChildren (blockStatement);
    }
    
    public virtual void VisitExpressionStatement (ExpressionStatement expressionStatement)
    {
      VisitChildren (expressionStatement);
    }
    
    public virtual void VisitBreakStatement (BreakStatement breakStatement)
    {
      VisitChildren (breakStatement);
    }
    
    public virtual void VisitCheckedStatement (CheckedStatement checkedStatement)
    {
      VisitChildren (checkedStatement);
    }
    
    public virtual void VisitContinueStatement (ContinueStatement continueStatement)
    {
      VisitChildren (continueStatement);
    }
    
    public virtual void VisitDoWhileStatement (DoWhileStatement doWhileStatement)
    {
      VisitChildren (doWhileStatement);
    }
    
    public virtual void VisitEmptyStatement (EmptyStatement emptyStatement)
    {
      VisitChildren (emptyStatement);
    }
    
    public virtual void VisitFixedStatement (FixedStatement fixedStatement)
    {
      VisitChildren (fixedStatement);
    }
    
    public virtual void VisitForeachStatement (ForeachStatement foreachStatement)
    {
      VisitChildren (foreachStatement);
    }
    
    public virtual void VisitForStatement (ForStatement forStatement)
    {
      VisitChildren (forStatement);
    }
    
    public virtual void VisitGotoCaseStatement (GotoCaseStatement gotoCaseStatement)
    {
      VisitChildren (gotoCaseStatement);
    }
    
    public virtual void VisitGotoDefaultStatement (GotoDefaultStatement gotoDefaultStatement)
    {
      VisitChildren (gotoDefaultStatement);
    }
    
    public virtual void VisitGotoStatement (GotoStatement gotoStatement)
    {
      VisitChildren (gotoStatement);
    }
    
    public virtual void VisitIfElseStatement (IfElseStatement ifElseStatement)
    {
      VisitChildren (ifElseStatement);
    }
    
    public virtual void VisitLabelStatement (LabelStatement labelStatement)
    {
      VisitChildren (labelStatement);
    }
    
    public virtual void VisitLockStatement (LockStatement lockStatement)
    {
      VisitChildren (lockStatement);
    }
    
    public virtual void VisitReturnStatement (ReturnStatement returnStatement)
    {
      VisitChildren (returnStatement);
    }
    
    public virtual void VisitSwitchStatement (SwitchStatement switchStatement)
    {
      VisitChildren (switchStatement);
    }
    
    public virtual void VisitSwitchSection (SwitchSection switchSection)
    {
      VisitChildren (switchSection);
    }
    
    public virtual void VisitCaseLabel (CaseLabel caseLabel)
    {
      VisitChildren (caseLabel);
    }
    
    public virtual void VisitThrowStatement (ThrowStatement throwStatement)
    {
      VisitChildren (throwStatement);
    }
    
    public virtual void VisitTryCatchStatement (TryCatchStatement tryCatchStatement)
    {
      VisitChildren (tryCatchStatement);
    }
    
    public virtual void VisitCatchClause (CatchClause catchClause)
    {
      VisitChildren (catchClause);
    }
    
    public virtual void VisitUncheckedStatement (UncheckedStatement uncheckedStatement)
    {
      VisitChildren (uncheckedStatement);
    }
    
    public virtual void VisitUnsafeStatement (UnsafeStatement unsafeStatement)
    {
      VisitChildren (unsafeStatement);
    }
    
    public virtual void VisitUsingStatement (UsingStatement usingStatement)
    {
      VisitChildren (usingStatement);
    }
    
    public virtual void VisitVariableDeclarationStatement (VariableDeclarationStatement variableDeclarationStatement)
    {
      VisitChildren (variableDeclarationStatement);
    }
    
    public virtual void VisitWhileStatement (WhileStatement whileStatement)
    {
      VisitChildren (whileStatement);
    }
    
    public virtual void VisitYieldBreakStatement (YieldBreakStatement yieldBreakStatement)
    {
      VisitChildren (yieldBreakStatement);
    }
    
    public virtual void VisitYieldReturnStatement (YieldReturnStatement yieldReturnStatement)
    {
      VisitChildren (yieldReturnStatement);
    }
    
    public virtual void VisitAnonymousMethodExpression (AnonymousMethodExpression anonymousMethodExpression)
    {
      VisitChildren (anonymousMethodExpression);
    }
    
    public virtual void VisitLambdaExpression (LambdaExpression lambdaExpression)
    {
      VisitChildren (lambdaExpression);
    }
    
    public virtual void VisitAssignmentExpression (AssignmentExpression assignmentExpression)
    {
      VisitChildren (assignmentExpression);
    }
    
    public virtual void VisitBaseReferenceExpression (BaseReferenceExpression baseReferenceExpression)
    {
      VisitChildren (baseReferenceExpression);
    }
    
    public virtual void VisitBinaryOperatorExpression (BinaryOperatorExpression binaryOperatorExpression)
    {
      VisitChildren (binaryOperatorExpression);
    }
    
    public virtual void VisitCastExpression (CastExpression castExpression)
    {
      VisitChildren (castExpression);
    }
    
    public virtual void VisitCheckedExpression (CheckedExpression checkedExpression)
    {
      VisitChildren (checkedExpression);
    }
    
    public virtual void VisitConditionalExpression (ConditionalExpression conditionalExpression)
    {
      VisitChildren (conditionalExpression);
    }
    
    public virtual void VisitIdentifierExpression (IdentifierExpression identifierExpression)
    {
      VisitChildren (identifierExpression);
    }
    
    public virtual void VisitIndexerExpression (IndexerExpression indexerExpression)
    {
      VisitChildren (indexerExpression);
    }
    
    public virtual void VisitInvocationExpression (InvocationExpression invocationExpression)
    {
      VisitChildren (invocationExpression);
    }
    
    public virtual void VisitDirectionExpression (DirectionExpression directionExpression)
    {
      VisitChildren (directionExpression);
    }
    
    public virtual void VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression)
    {
      VisitChildren (memberReferenceExpression);
    }
    
    public virtual void VisitNullReferenceExpression (NullReferenceExpression nullReferenceExpression)
    {
      VisitChildren (nullReferenceExpression);
    }
    
    public virtual void VisitObjectCreateExpression (ObjectCreateExpression objectCreateExpression)
    {
      VisitChildren (objectCreateExpression);
    }
    
    public virtual void VisitAnonymousTypeCreateExpression(AnonymousTypeCreateExpression anonymousTypeCreateExpression)
    {
      VisitChildren (anonymousTypeCreateExpression);
    }
    
    public virtual void VisitArrayCreateExpression (ArrayCreateExpression arrayCreateExpression)
    {
      VisitChildren (arrayCreateExpression);
    }
    
    public virtual void VisitParenthesizedExpression (ParenthesizedExpression parenthesizedExpression)
    {
      VisitChildren (parenthesizedExpression);
    }
    
    public virtual void VisitPointerReferenceExpression (PointerReferenceExpression pointerReferenceExpression)
    {
      VisitChildren (pointerReferenceExpression);
    }
    
    public virtual void VisitPrimitiveExpression(PrimitiveExpression primitiveExpression)
    {
      VisitChildren (primitiveExpression);
    }
    
    public virtual void VisitSizeOfExpression (SizeOfExpression sizeOfExpression)
    {
      VisitChildren (sizeOfExpression);
    }
    
    public virtual void VisitStackAllocExpression (StackAllocExpression stackAllocExpression)
    {
      VisitChildren (stackAllocExpression);
    }
    
    public virtual void VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression)
    {
      VisitChildren (thisReferenceExpression);
    }
    
    public virtual void VisitTypeOfExpression (TypeOfExpression typeOfExpression)
    {
      VisitChildren (typeOfExpression);
    }
    
    public virtual void VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression)
    {
      VisitChildren (typeReferenceExpression);
    }
    
    public virtual void VisitUnaryOperatorExpression (UnaryOperatorExpression unaryOperatorExpression)
    {
      VisitChildren (unaryOperatorExpression);
    }
    
    public virtual void VisitUncheckedExpression (UncheckedExpression uncheckedExpression)
    {
      VisitChildren (uncheckedExpression);
    }
    
    public virtual void VisitQueryExpression(QueryExpression queryExpression)
    {
      VisitChildren (queryExpression);
    }
    
    public virtual void VisitQueryContinuationClause(QueryContinuationClause queryContinuationClause)
    {
      VisitChildren (queryContinuationClause);
    }
    
    public virtual void VisitQueryFromClause(QueryFromClause queryFromClause)
    {
      VisitChildren (queryFromClause);
    }
    
    public virtual void VisitQueryLetClause(QueryLetClause queryLetClause)
    {
      VisitChildren (queryLetClause);
    }
    
    public virtual void VisitQueryWhereClause(QueryWhereClause queryWhereClause)
    {
      VisitChildren (queryWhereClause);
    }
    
    public virtual void VisitQueryJoinClause(QueryJoinClause queryJoinClause)
    {
      VisitChildren (queryJoinClause);
    }
    
    public virtual void VisitQueryOrderClause(QueryOrderClause queryOrderClause)
    {
      VisitChildren (queryOrderClause);
    }
    
    public virtual void VisitQueryOrdering(QueryOrdering queryOrdering)
    {
      VisitChildren (queryOrdering);
    }
    
    public virtual void VisitQuerySelectClause(QuerySelectClause querySelectClause)
    {
      VisitChildren (querySelectClause);
    }
    
    public virtual void VisitQueryGroupClause(QueryGroupClause queryGroupClause)
    {
      VisitChildren (queryGroupClause);
    }
    
    public virtual void VisitAsExpression (AsExpression asExpression)
    {
      VisitChildren (asExpression);
    }
    
    public virtual void VisitIsExpression (IsExpression isExpression)
    {
      VisitChildren (isExpression);
    }
    
    public virtual void VisitDefaultValueExpression (DefaultValueExpression defaultValueExpression)
    {
      VisitChildren (defaultValueExpression);
    }
    
    public virtual void VisitUndocumentedExpression (UndocumentedExpression undocumentedExpression)
    {
      VisitChildren (undocumentedExpression);
    }
    
    public virtual void VisitArrayInitializerExpression (ArrayInitializerExpression arrayInitializerExpression)
    {
      VisitChildren (arrayInitializerExpression);
    }
    
    public virtual void VisitArraySpecifier (ArraySpecifier arraySpecifier)
    {
      VisitChildren (arraySpecifier);
    }
    
    public virtual void VisitNamedArgumentExpression (NamedArgumentExpression namedArgumentExpression)
    {
      VisitChildren (namedArgumentExpression);
    }
    
    public virtual void VisitNamedExpression (NamedExpression namedExpression)
    {
      VisitChildren (namedExpression);
    }

    public virtual void VisitErrorNode(AstNode errorNode)
    {
      VisitChildren(errorNode);
    }

    public virtual void VisitPatternPlaceholder(AstNode placeholder, PatternMatching.Pattern pattern)
    {
      VisitChildren (placeholder);
    }
  }
  
  /// <summary>
  /// AST visitor with a default implementation that visits all node depth-first.
  /// </summary>
  public abstract class DepthFirstAstVisitor<T> : IAstVisitor<T>
  {
    protected virtual T VisitChildren (AstNode node)
    {
      AstNode next;
      for (var child = node.FirstChild; child != null; child = next) {
        // Store next to allow the loop to continue
        // if the visitor removes/replaces child.
        next = child.NextSibling;
        child.AcceptVisitor (this);
      }
      return default (T);
    }
    
    public virtual T VisitNullNode(AstNode nullNode)
    {
      // Should we call VisitChildren here?
      // We usually want to ignore null nodes.
      // Older NR versions (before VisitNullNode was introduced) didn't call VisitChildren() with null nodes;
      // so changing this might break VisitChildren() overrides that expect the node to be part of the AST.
      return default (T);
    }
    
    public virtual T VisitSyntaxTree (SyntaxTree unit)
    {
      return VisitChildren (unit);
    }
    
    public virtual T VisitComment (Comment comment)
    {
      return VisitChildren (comment);
    }
    
    public virtual T VisitNewLine(NewLineNode newLineNode)
    {
      return VisitChildren(newLineNode);
    }
    
    public virtual T VisitWhitespace(WhitespaceNode whitespaceNode)
    {
      return VisitChildren(whitespaceNode);
    }

    public virtual T VisitText(TextNode textNode)
    {
      return VisitChildren(textNode);
    }

    public virtual T VisitDocumentationReference (DocumentationReference documentationReference)
    {
      return VisitChildren (documentationReference);
    }
    
    public virtual T VisitPreProcessorDirective (PreProcessorDirective preProcessorDirective)
    {
      return VisitChildren (preProcessorDirective);
    }

    public virtual T VisitIdentifier (Identifier identifier)
    {
      return VisitChildren (identifier);
    }
    
    public virtual T VisitCSharpTokenNode (CSharpTokenNode token)
    {
      return VisitChildren (token);
    }
    
    public virtual T VisitPrimitiveType (PrimitiveType primitiveType)
    {
      return VisitChildren (primitiveType);
    }
    
    public virtual T VisitComposedType (ComposedType composedType)
    {
      return VisitChildren (composedType);
    }
    
    public virtual T VisitSimpleType(SimpleType simpleType)
    {
      return VisitChildren (simpleType);
    }
    
    public virtual T VisitMemberType(MemberType memberType)
    {
      return VisitChildren (memberType);
    }
    
    public virtual T VisitAttribute (Attribute attribute)
    {
      return VisitChildren (attribute);
    }
    
    public virtual T VisitAttributeSection (AttributeSection attributeSection)
    {
      return VisitChildren (attributeSection);
    }
    
    public virtual T VisitDelegateDeclaration (DelegateDeclaration delegateDeclaration)
    {
      return VisitChildren (delegateDeclaration);
    }
    
    public virtual T VisitNamespaceDeclaration (NamespaceDeclaration namespaceDeclaration)
    {
      return VisitChildren (namespaceDeclaration);
    }
    
    public virtual T VisitTypeDeclaration (TypeDeclaration typeDeclaration)
    {
      return VisitChildren (typeDeclaration);
    }
    
    public virtual T VisitTypeParameterDeclaration (TypeParameterDeclaration typeParameterDeclaration)
    {
      return VisitChildren (typeParameterDeclaration);
    }
    
    public virtual T VisitEnumMemberDeclaration (EnumMemberDeclaration enumMemberDeclaration)
    {
      return VisitChildren (enumMemberDeclaration);
    }
    
    public virtual T VisitUsingDeclaration (UsingDeclaration usingDeclaration)
    {
      return VisitChildren (usingDeclaration);
    }
    
    public virtual T VisitUsingAliasDeclaration (UsingAliasDeclaration usingDeclaration)
    {
      return VisitChildren (usingDeclaration);
    }
    
    public virtual T VisitExternAliasDeclaration(ExternAliasDeclaration externAliasDeclaration)
    {
      return VisitChildren (externAliasDeclaration);
    }
    
    public virtual T VisitConstructorDeclaration (ConstructorDeclaration constructorDeclaration)
    {
      return VisitChildren (constructorDeclaration);
    }
    
    public virtual T VisitConstructorInitializer (ConstructorInitializer constructorInitializer)
    {
      return VisitChildren (constructorInitializer);
    }
    
    public virtual T VisitDestructorDeclaration (DestructorDeclaration destructorDeclaration)
    {
      return VisitChildren (destructorDeclaration);
    }
    
    public virtual T VisitEventDeclaration (EventDeclaration eventDeclaration)
    {
      return VisitChildren (eventDeclaration);
    }
    
    public virtual T VisitCustomEventDeclaration (CustomEventDeclaration eventDeclaration)
    {
      return VisitChildren (eventDeclaration);
    }
    
    public virtual T VisitFieldDeclaration (FieldDeclaration fieldDeclaration)
    {
      return VisitChildren (fieldDeclaration);
    }
    
    public virtual T VisitFixedFieldDeclaration (FixedFieldDeclaration fixedFieldDeclaration)
    {
      return VisitChildren (fixedFieldDeclaration);
    }
    
    public virtual T VisitFixedVariableInitializer (FixedVariableInitializer fixedVariableInitializer)
    {
      return VisitChildren (fixedVariableInitializer);
    }
    
    public virtual T VisitIndexerDeclaration (IndexerDeclaration indexerDeclaration)
    {
      return VisitChildren (indexerDeclaration);
    }
    
    public virtual T VisitMethodDeclaration (MethodDeclaration methodDeclaration)
    {
      return VisitChildren (methodDeclaration);
    }
    
    public virtual T VisitOperatorDeclaration (OperatorDeclaration operatorDeclaration)
    {
      return VisitChildren (operatorDeclaration);
    }
    
    public virtual T VisitPropertyDeclaration (PropertyDeclaration propertyDeclaration)
    {
      return VisitChildren (propertyDeclaration);
    }
    
    public virtual T VisitAccessor (Accessor accessor)
    {
      return VisitChildren (accessor);
    }
    
    public virtual T VisitVariableInitializer (VariableInitializer variableInitializer)
    {
      return VisitChildren (variableInitializer);
    }
    
    public virtual T VisitParameterDeclaration (ParameterDeclaration parameterDeclaration)
    {
      return VisitChildren (parameterDeclaration);
    }
    
    public virtual T VisitConstraint (Constraint constraint)
    {
      return VisitChildren (constraint);
    }
    
    public virtual T VisitBlockStatement (BlockStatement blockStatement)
    {
      return VisitChildren (blockStatement);
    }
    
    public virtual T VisitExpressionStatement (ExpressionStatement expressionStatement)
    {
      return VisitChildren (expressionStatement);
    }
    
    public virtual T VisitBreakStatement (BreakStatement breakStatement)
    {
      return VisitChildren (breakStatement);
    }
    
    public virtual T VisitCheckedStatement (CheckedStatement checkedStatement)
    {
      return VisitChildren (checkedStatement);
    }
    
    public virtual T VisitContinueStatement (ContinueStatement continueStatement)
    {
      return VisitChildren (continueStatement);
    }
    
    public virtual T VisitDoWhileStatement (DoWhileStatement doWhileStatement)
    {
      return VisitChildren (doWhileStatement);
    }
    
    public virtual T VisitEmptyStatement (EmptyStatement emptyStatement)
    {
      return VisitChildren (emptyStatement);
    }
    
    public virtual T VisitFixedStatement (FixedStatement fixedStatement)
    {
      return VisitChildren (fixedStatement);
    }
    
    public virtual T VisitForeachStatement (ForeachStatement foreachStatement)
    {
      return VisitChildren (foreachStatement);
    }
    
    public virtual T VisitForStatement (ForStatement forStatement)
    {
      return VisitChildren (forStatement);
    }
    
    public virtual T VisitGotoCaseStatement (GotoCaseStatement gotoCaseStatement)
    {
      return VisitChildren (gotoCaseStatement);
    }
    
    public virtual T VisitGotoDefaultStatement (GotoDefaultStatement gotoDefaultStatement)
    {
      return VisitChildren (gotoDefaultStatement);
    }
    
    public virtual T VisitGotoStatement (GotoStatement gotoStatement)
    {
      return VisitChildren (gotoStatement);
    }
    
    public virtual T VisitIfElseStatement (IfElseStatement ifElseStatement)
    {
      return VisitChildren (ifElseStatement);
    }
    
    public virtual T VisitLabelStatement (LabelStatement labelStatement)
    {
      return VisitChildren (labelStatement);
    }
    
    public virtual T VisitLockStatement (LockStatement lockStatement)
    {
      return VisitChildren (lockStatement);
    }
    
    public virtual T VisitReturnStatement (ReturnStatement returnStatement)
    {
      return VisitChildren (returnStatement);
    }
    
    public virtual T VisitSwitchStatement (SwitchStatement switchStatement)
    {
      return VisitChildren (switchStatement);
    }
    
    public virtual T VisitSwitchSection (SwitchSection switchSection)
    {
      return VisitChildren (switchSection);
    }
    
    public virtual T VisitCaseLabel (CaseLabel caseLabel)
    {
      return VisitChildren (caseLabel);
    }
    
    public virtual T VisitThrowStatement (ThrowStatement throwStatement)
    {
      return VisitChildren (throwStatement);
    }
    
    public virtual T VisitTryCatchStatement (TryCatchStatement tryCatchStatement)
    {
      return VisitChildren (tryCatchStatement);
    }
    
    public virtual T VisitCatchClause (CatchClause catchClause)
    {
      return VisitChildren (catchClause);
    }
    
    public virtual T VisitUncheckedStatement (UncheckedStatement uncheckedStatement)
    {
      return VisitChildren (uncheckedStatement);
    }
    
    public virtual T VisitUnsafeStatement (UnsafeStatement unsafeStatement)
    {
      return VisitChildren (unsafeStatement);
    }
    
    public virtual T VisitUsingStatement (UsingStatement usingStatement)
    {
      return VisitChildren (usingStatement);
    }
    
    public virtual T VisitVariableDeclarationStatement (VariableDeclarationStatement variableDeclarationStatement)
    {
      return VisitChildren (variableDeclarationStatement);
    }
    
    public virtual T VisitWhileStatement (WhileStatement whileStatement)
    {
      return VisitChildren (whileStatement);
    }
    
    public virtual T VisitYieldBreakStatement (YieldBreakStatement yieldBreakStatement)
    {
      return VisitChildren (yieldBreakStatement);
    }
    
    public virtual T VisitYieldReturnStatement (YieldReturnStatement yieldReturnStatement)
    {
      return VisitChildren (yieldReturnStatement);
    }
    
    public virtual T VisitAnonymousMethodExpression (AnonymousMethodExpression anonymousMethodExpression)
    {
      return VisitChildren (anonymousMethodExpression);
    }
    
    public virtual T VisitLambdaExpression (LambdaExpression lambdaExpression)
    {
      return VisitChildren (lambdaExpression);
    }
    
    public virtual T VisitAssignmentExpression (AssignmentExpression assignmentExpression)
    {
      return VisitChildren (assignmentExpression);
    }
    
    public virtual T VisitBaseReferenceExpression (BaseReferenceExpression baseReferenceExpression)
    {
      return VisitChildren (baseReferenceExpression);
    }
    
    public virtual T VisitBinaryOperatorExpression (BinaryOperatorExpression binaryOperatorExpression)
    {
      return VisitChildren (binaryOperatorExpression);
    }
    
    public virtual T VisitCastExpression (CastExpression castExpression)
    {
      return VisitChildren (castExpression);
    }
    
    public virtual T VisitCheckedExpression (CheckedExpression checkedExpression)
    {
      return VisitChildren (checkedExpression);
    }
    
    public virtual T VisitConditionalExpression (ConditionalExpression conditionalExpression)
    {
      return VisitChildren (conditionalExpression);
    }
    
    public virtual T VisitIdentifierExpression (IdentifierExpression identifierExpression)
    {
      return VisitChildren (identifierExpression);
    }
    
    public virtual T VisitIndexerExpression (IndexerExpression indexerExpression)
    {
      return VisitChildren (indexerExpression);
    }
    
    public virtual T VisitInvocationExpression (InvocationExpression invocationExpression)
    {
      return VisitChildren (invocationExpression);
    }
    
    public virtual T VisitDirectionExpression (DirectionExpression directionExpression)
    {
      return VisitChildren (directionExpression);
    }
    
    public virtual T VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression)
    {
      return VisitChildren (memberReferenceExpression);
    }
    
    public virtual T VisitNullReferenceExpression (NullReferenceExpression nullReferenceExpression)
    {
      return VisitChildren (nullReferenceExpression);
    }
    
    public virtual T VisitObjectCreateExpression (ObjectCreateExpression objectCreateExpression)
    {
      return VisitChildren (objectCreateExpression);
    }
    
    public virtual T VisitAnonymousTypeCreateExpression(AnonymousTypeCreateExpression anonymousTypeCreateExpression)
    {
      return VisitChildren (anonymousTypeCreateExpression);
    }
    
    public virtual T VisitArrayCreateExpression (ArrayCreateExpression arrayCreateExpression)
    {
      return VisitChildren (arrayCreateExpression);
    }
    
    public virtual T VisitParenthesizedExpression (ParenthesizedExpression parenthesizedExpression)
    {
      return VisitChildren (parenthesizedExpression);
    }
    
    public virtual T VisitPointerReferenceExpression (PointerReferenceExpression pointerReferenceExpression)
    {
      return VisitChildren (pointerReferenceExpression);
    }
    
    public virtual T VisitPrimitiveExpression(PrimitiveExpression primitiveExpression)
    {
      return VisitChildren (primitiveExpression);
    }
    
    public virtual T VisitSizeOfExpression (SizeOfExpression sizeOfExpression)
    {
      return VisitChildren (sizeOfExpression);
    }
    
    public virtual T VisitStackAllocExpression (StackAllocExpression stackAllocExpression)
    {
      return VisitChildren (stackAllocExpression);
    }
    
    public virtual T VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression)
    {
      return VisitChildren (thisReferenceExpression);
    }
    
    public virtual T VisitTypeOfExpression (TypeOfExpression typeOfExpression)
    {
      return VisitChildren (typeOfExpression);
    }
    
    public virtual T VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression)
    {
      return VisitChildren (typeReferenceExpression);
    }
    
    public virtual T VisitUnaryOperatorExpression (UnaryOperatorExpression unaryOperatorExpression)
    {
      return VisitChildren (unaryOperatorExpression);
    }
    
    public virtual T VisitUncheckedExpression (UncheckedExpression uncheckedExpression)
    {
      return VisitChildren (uncheckedExpression);
    }
    
    public virtual T VisitQueryExpression(QueryExpression queryExpression)
    {
      return VisitChildren (queryExpression);
    }
    
    public virtual T VisitQueryContinuationClause(QueryContinuationClause queryContinuationClause)
    {
      return VisitChildren (queryContinuationClause);
    }
    
    public virtual T VisitQueryFromClause(QueryFromClause queryFromClause)
    {
      return VisitChildren (queryFromClause);
    }
    
    public virtual T VisitQueryLetClause(QueryLetClause queryLetClause)
    {
      return VisitChildren (queryLetClause);
    }
    
    public virtual T VisitQueryWhereClause(QueryWhereClause queryWhereClause)
    {
      return VisitChildren (queryWhereClause);
    }
    
    public virtual T VisitQueryJoinClause(QueryJoinClause queryJoinClause)
    {
      return VisitChildren (queryJoinClause);
    }
    
    public virtual T VisitQueryOrderClause(QueryOrderClause queryOrderClause)
    {
      return VisitChildren (queryOrderClause);
    }
    
    public virtual T VisitQueryOrdering(QueryOrdering queryOrdering)
    {
      return VisitChildren (queryOrdering);
    }
    
    public virtual T VisitQuerySelectClause(QuerySelectClause querySelectClause)
    {
      return VisitChildren (querySelectClause);
    }
    
    public virtual T VisitQueryGroupClause(QueryGroupClause queryGroupClause)
    {
      return VisitChildren (queryGroupClause);
    }
    
    public virtual T VisitAsExpression (AsExpression asExpression)
    {
      return VisitChildren (asExpression);
    }
    
    public virtual T VisitIsExpression (IsExpression isExpression)
    {
      return VisitChildren (isExpression);
    }
    
    public virtual T VisitDefaultValueExpression (DefaultValueExpression defaultValueExpression)
    {
      return VisitChildren (defaultValueExpression);
    }
    
    public virtual T VisitUndocumentedExpression (UndocumentedExpression undocumentedExpression)
    {
      return VisitChildren (undocumentedExpression);
    }
    
    public virtual T VisitArrayInitializerExpression (ArrayInitializerExpression arrayInitializerExpression)
    {
      return VisitChildren (arrayInitializerExpression);
    }
    
    public virtual T VisitArraySpecifier (ArraySpecifier arraySpecifier)
    {
      return VisitChildren (arraySpecifier);
    }
    
    public virtual T VisitNamedArgumentExpression (NamedArgumentExpression namedArgumentExpression)
    {
      return VisitChildren (namedArgumentExpression);
    }
    
    public virtual T VisitNamedExpression (NamedExpression namedExpression)
    {
      return VisitChildren (namedExpression);
    }

    public virtual T VisitErrorNode(AstNode errorNode)
    {
      return VisitChildren(errorNode);
    }

    public virtual T VisitPatternPlaceholder(AstNode placeholder, PatternMatching.Pattern pattern)
    {
      return VisitChildren (placeholder);
    }
  }
  
  /// <summary>
  /// AST visitor with a default implementation that visits all node depth-first.
  /// </summary>
  public abstract class DepthFirstAstVisitor<T, S> : IAstVisitor<T, S>
  {
    protected virtual S VisitChildren (AstNode node, T data)
    {
      AstNode next;
      for (var child = node.FirstChild; child != null; child = next) {
        // Store next to allow the loop to continue
        // if the visitor removes/replaces child.
        next = child.NextSibling;
        child.AcceptVisitor (this, data);
      }
      return default (S);
    }
    
    public virtual S VisitNullNode(AstNode nullNode, T data)
    {
      // Should we call VisitChildren here?
      // We usually want to ignore null nodes.
      // Older NR versions (before VisitNullNode was introduced) didn't call VisitChildren() with null nodes;
      // so changing this might break VisitChildren() overrides that expect the node to be part of the AST.
      return default (S);
    }
    
    public virtual S VisitSyntaxTree (SyntaxTree unit, T data)
    {
      return VisitChildren (unit, data);
    }
    
    public virtual S VisitComment (Comment comment, T data)
    {
      return VisitChildren (comment, data);
    }
    
    public virtual S VisitNewLine(NewLineNode newLineNode, T data)
    {
      return VisitChildren(newLineNode, data);
    }

    public virtual S VisitWhitespace(WhitespaceNode whitespaceNode, T data)
    {
      return VisitChildren(whitespaceNode, data);
    }

    public virtual S VisitText(TextNode textNode, T data)
    {
      return VisitChildren(textNode, data);
    }

    public virtual S VisitDocumentationReference (DocumentationReference documentationReference, T data)
    {
      return VisitChildren (documentationReference, data);
    }
    
    public virtual S VisitPreProcessorDirective (PreProcessorDirective preProcessorDirective, T data)
    {
      return VisitChildren (preProcessorDirective, data);
    }

    public virtual S VisitIdentifier (Identifier identifier, T data)
    {
      return VisitChildren (identifier, data);
    }
    
    public virtual S VisitCSharpTokenNode (CSharpTokenNode token, T data)
    {
      return VisitChildren (token, data);
    }
    
    public virtual S VisitPrimitiveType (PrimitiveType primitiveType, T data)
    {
      return VisitChildren (primitiveType, data);
    }
    
    public virtual S VisitComposedType (ComposedType composedType, T data)
    {
      return VisitChildren (composedType, data);
    }
    
    public virtual S VisitSimpleType(SimpleType simpleType, T data)
    {
      return VisitChildren (simpleType, data);
    }
    
    public virtual S VisitMemberType(MemberType memberType, T data)
    {
      return VisitChildren (memberType, data);
    }
    
    public virtual S VisitAttribute (Attribute attribute, T data)
    {
      return VisitChildren (attribute, data);
    }
    
    public virtual S VisitAttributeSection (AttributeSection attributeSection, T data)
    {
      return VisitChildren (attributeSection, data);
    }
    
    public virtual S VisitDelegateDeclaration (DelegateDeclaration delegateDeclaration, T data)
    {
      return VisitChildren (delegateDeclaration, data);
    }
    
    public virtual S VisitNamespaceDeclaration (NamespaceDeclaration namespaceDeclaration, T data)
    {
      return VisitChildren (namespaceDeclaration, data);
    }
    
    public virtual S VisitTypeDeclaration (TypeDeclaration typeDeclaration, T data)
    {
      return VisitChildren (typeDeclaration, data);
    }
    
    public virtual S VisitTypeParameterDeclaration (TypeParameterDeclaration typeParameterDeclaration, T data)
    {
      return VisitChildren (typeParameterDeclaration, data);
    }
    
    public virtual S VisitEnumMemberDeclaration (EnumMemberDeclaration enumMemberDeclaration, T data)
    {
      return VisitChildren (enumMemberDeclaration, data);
    }
    
    public virtual S VisitUsingDeclaration (UsingDeclaration usingDeclaration, T data)
    {
      return VisitChildren (usingDeclaration, data);
    }
    
    public virtual S VisitUsingAliasDeclaration (UsingAliasDeclaration usingDeclaration, T data)
    {
      return VisitChildren (usingDeclaration, data);
    }
    
    public virtual S VisitExternAliasDeclaration(ExternAliasDeclaration externAliasDeclaration, T data)
    {
      return VisitChildren (externAliasDeclaration, data);
    }
    
    public virtual S VisitConstructorDeclaration (ConstructorDeclaration constructorDeclaration, T data)
    {
      return VisitChildren (constructorDeclaration, data);
    }
    
    public virtual S VisitConstructorInitializer (ConstructorInitializer constructorInitializer, T data)
    {
      return VisitChildren (constructorInitializer, data);
    }
    
    public virtual S VisitDestructorDeclaration (DestructorDeclaration destructorDeclaration, T data)
    {
      return VisitChildren (destructorDeclaration, data);
    }
    
    public virtual S VisitEventDeclaration (EventDeclaration eventDeclaration, T data)
    {
      return VisitChildren (eventDeclaration, data);
    }
    
    public virtual S VisitCustomEventDeclaration (CustomEventDeclaration eventDeclaration, T data)
    {
      return VisitChildren (eventDeclaration, data);
    }
    
    public virtual S VisitFieldDeclaration (FieldDeclaration fieldDeclaration, T data)
    {
      return VisitChildren (fieldDeclaration, data);
    }
    
    public virtual S VisitFixedFieldDeclaration (FixedFieldDeclaration fixedFieldDeclaration, T data)
    {
      return VisitChildren (fixedFieldDeclaration, data);
    }
    
    public virtual S VisitFixedVariableInitializer (FixedVariableInitializer fixedVariableInitializer, T data)
    {
      return VisitChildren (fixedVariableInitializer, data);
    }
    
    public virtual S VisitIndexerDeclaration (IndexerDeclaration indexerDeclaration, T data)
    {
      return VisitChildren (indexerDeclaration, data);
    }
    
    public virtual S VisitMethodDeclaration (MethodDeclaration methodDeclaration, T data)
    {
      return VisitChildren (methodDeclaration, data);
    }
    
    public virtual S VisitOperatorDeclaration (OperatorDeclaration operatorDeclaration, T data)
    {
      return VisitChildren (operatorDeclaration, data);
    }
    
    public virtual S VisitPropertyDeclaration (PropertyDeclaration propertyDeclaration, T data)
    {
      return VisitChildren (propertyDeclaration, data);
    }
    
    public virtual S VisitAccessor (Accessor accessor, T data)
    {
      return VisitChildren (accessor, data);
    }
    
    public virtual S VisitVariableInitializer (VariableInitializer variableInitializer, T data)
    {
      return VisitChildren (variableInitializer, data);
    }
    
    public virtual S VisitParameterDeclaration (ParameterDeclaration parameterDeclaration, T data)
    {
      return VisitChildren (parameterDeclaration, data);
    }
    
    public virtual S VisitConstraint (Constraint constraint, T data)
    {
      return VisitChildren (constraint, data);
    }
    
    public virtual S VisitBlockStatement (BlockStatement blockStatement, T data)
    {
      return VisitChildren (blockStatement, data);
    }
    
    public virtual S VisitExpressionStatement (ExpressionStatement expressionStatement, T data)
    {
      return VisitChildren (expressionStatement, data);
    }
    
    public virtual S VisitBreakStatement (BreakStatement breakStatement, T data)
    {
      return VisitChildren (breakStatement, data);
    }
    
    public virtual S VisitCheckedStatement (CheckedStatement checkedStatement, T data)
    {
      return VisitChildren (checkedStatement, data);
    }
    
    public virtual S VisitContinueStatement (ContinueStatement continueStatement, T data)
    {
      return VisitChildren (continueStatement, data);
    }
    
    public virtual S VisitDoWhileStatement (DoWhileStatement doWhileStatement, T data)
    {
      return VisitChildren (doWhileStatement, data);
    }
    
    public virtual S VisitEmptyStatement (EmptyStatement emptyStatement, T data)
    {
      return VisitChildren (emptyStatement, data);
    }
    
    public virtual S VisitFixedStatement (FixedStatement fixedStatement, T data)
    {
      return VisitChildren (fixedStatement, data);
    }
    
    public virtual S VisitForeachStatement (ForeachStatement foreachStatement, T data)
    {
      return VisitChildren (foreachStatement, data);
    }
    
    public virtual S VisitForStatement (ForStatement forStatement, T data)
    {
      return VisitChildren (forStatement, data);
    }
    
    public virtual S VisitGotoCaseStatement (GotoCaseStatement gotoCaseStatement, T data)
    {
      return VisitChildren (gotoCaseStatement, data);
    }
    
    public virtual S VisitGotoDefaultStatement (GotoDefaultStatement gotoDefaultStatement, T data)
    {
      return VisitChildren (gotoDefaultStatement, data);
    }
    
    public virtual S VisitGotoStatement (GotoStatement gotoStatement, T data)
    {
      return VisitChildren (gotoStatement, data);
    }
    
    public virtual S VisitIfElseStatement (IfElseStatement ifElseStatement, T data)
    {
      return VisitChildren (ifElseStatement, data);
    }
    
    public virtual S VisitLabelStatement (LabelStatement labelStatement, T data)
    {
      return VisitChildren (labelStatement, data);
    }
    
    public virtual S VisitLockStatement (LockStatement lockStatement, T data)
    {
      return VisitChildren (lockStatement, data);
    }
    
    public virtual S VisitReturnStatement (ReturnStatement returnStatement, T data)
    {
      return VisitChildren (returnStatement, data);
    }
    
    public virtual S VisitSwitchStatement (SwitchStatement switchStatement, T data)
    {
      return VisitChildren (switchStatement, data);
    }
    
    public virtual S VisitSwitchSection (SwitchSection switchSection, T data)
    {
      return VisitChildren (switchSection, data);
    }
    
    public virtual S VisitCaseLabel (CaseLabel caseLabel, T data)
    {
      return VisitChildren (caseLabel, data);
    }
    
    public virtual S VisitThrowStatement (ThrowStatement throwStatement, T data)
    {
      return VisitChildren (throwStatement, data);
    }
    
    public virtual S VisitTryCatchStatement (TryCatchStatement tryCatchStatement, T data)
    {
      return VisitChildren (tryCatchStatement, data);
    }
    
    public virtual S VisitCatchClause (CatchClause catchClause, T data)
    {
      return VisitChildren (catchClause, data);
    }
    
    public virtual S VisitUncheckedStatement (UncheckedStatement uncheckedStatement, T data)
    {
      return VisitChildren (uncheckedStatement, data);
    }
    
    public virtual S VisitUnsafeStatement (UnsafeStatement unsafeStatement, T data)
    {
      return VisitChildren (unsafeStatement, data);
    }
    
    public virtual S VisitUsingStatement (UsingStatement usingStatement, T data)
    {
      return VisitChildren (usingStatement, data);
    }
    
    public virtual S VisitVariableDeclarationStatement (VariableDeclarationStatement variableDeclarationStatement, T data)
    {
      return VisitChildren (variableDeclarationStatement, data);
    }
    
    public virtual S VisitWhileStatement (WhileStatement whileStatement, T data)
    {
      return VisitChildren (whileStatement, data);
    }
    
    public virtual S VisitYieldBreakStatement (YieldBreakStatement yieldBreakStatement, T data)
    {
      return VisitChildren (yieldBreakStatement, data);
    }
    
    public virtual S VisitYieldReturnStatement (YieldReturnStatement yieldReturnStatement, T data)
    {
      return VisitChildren (yieldReturnStatement, data);
    }
    
    public virtual S VisitAnonymousMethodExpression (AnonymousMethodExpression anonymousMethodExpression, T data)
    {
      return VisitChildren (anonymousMethodExpression, data);
    }
    
    public virtual S VisitLambdaExpression (LambdaExpression lambdaExpression, T data)
    {
      return VisitChildren (lambdaExpression, data);
    }
    
    public virtual S VisitAssignmentExpression (AssignmentExpression assignmentExpression, T data)
    {
      return VisitChildren (assignmentExpression, data);
    }
    
    public virtual S VisitBaseReferenceExpression (BaseReferenceExpression baseReferenceExpression, T data)
    {
      return VisitChildren (baseReferenceExpression, data);
    }
    
    public virtual S VisitBinaryOperatorExpression (BinaryOperatorExpression binaryOperatorExpression, T data)
    {
      return VisitChildren (binaryOperatorExpression, data);
    }
    
    public virtual S VisitCastExpression (CastExpression castExpression, T data)
    {
      return VisitChildren (castExpression, data);
    }
    
    public virtual S VisitCheckedExpression (CheckedExpression checkedExpression, T data)
    {
      return VisitChildren (checkedExpression, data);
    }
    
    public virtual S VisitConditionalExpression (ConditionalExpression conditionalExpression, T data)
    {
      return VisitChildren (conditionalExpression, data);
    }
    
    public virtual S VisitIdentifierExpression (IdentifierExpression identifierExpression, T data)
    {
      return VisitChildren (identifierExpression, data);
    }
    
    public virtual S VisitIndexerExpression (IndexerExpression indexerExpression, T data)
    {
      return VisitChildren (indexerExpression, data);
    }
    
    public virtual S VisitInvocationExpression (InvocationExpression invocationExpression, T data)
    {
      return VisitChildren (invocationExpression, data);
    }
    
    public virtual S VisitDirectionExpression (DirectionExpression directionExpression, T data)
    {
      return VisitChildren (directionExpression, data);
    }
    
    public virtual S VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression, T data)
    {
      return VisitChildren (memberReferenceExpression, data);
    }
    
    public virtual S VisitNullReferenceExpression (NullReferenceExpression nullReferenceExpression, T data)
    {
      return VisitChildren (nullReferenceExpression, data);
    }
    
    public virtual S VisitObjectCreateExpression (ObjectCreateExpression objectCreateExpression, T data)
    {
      return VisitChildren (objectCreateExpression, data);
    }
    
    public virtual S VisitAnonymousTypeCreateExpression(AnonymousTypeCreateExpression anonymousTypeCreateExpression, T data)
    {
      return VisitChildren (anonymousTypeCreateExpression, data);
    }
    
    public virtual S VisitArrayCreateExpression (ArrayCreateExpression arrayCreateExpression, T data)
    {
      return VisitChildren (arrayCreateExpression, data);
    }
    
    public virtual S VisitParenthesizedExpression (ParenthesizedExpression parenthesizedExpression, T data)
    {
      return VisitChildren (parenthesizedExpression, data);
    }
    
    public virtual S VisitPointerReferenceExpression (PointerReferenceExpression pointerReferenceExpression, T data)
    {
      return VisitChildren (pointerReferenceExpression, data);
    }
    
    public virtual S VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, T data)
    {
      return VisitChildren (primitiveExpression, data);
    }
    
    public virtual S VisitSizeOfExpression (SizeOfExpression sizeOfExpression, T data)
    {
      return VisitChildren (sizeOfExpression, data);
    }
    
    public virtual S VisitStackAllocExpression (StackAllocExpression stackAllocExpression, T data)
    {
      return VisitChildren (stackAllocExpression, data);
    }
    
    public virtual S VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, T data)
    {
      return VisitChildren (thisReferenceExpression, data);
    }
    
    public virtual S VisitTypeOfExpression (TypeOfExpression typeOfExpression, T data)
    {
      return VisitChildren (typeOfExpression, data);
    }
    
    public virtual S VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, T data)
    {
      return VisitChildren (typeReferenceExpression, data);
    }
    
    public virtual S VisitUnaryOperatorExpression (UnaryOperatorExpression unaryOperatorExpression, T data)
    {
      return VisitChildren (unaryOperatorExpression, data);
    }
    
    public virtual S VisitUncheckedExpression (UncheckedExpression uncheckedExpression, T data)
    {
      return VisitChildren (uncheckedExpression, data);
    }
    
    public virtual S VisitQueryExpression(QueryExpression queryExpression, T data)
    {
      return VisitChildren (queryExpression, data);
    }
    
    public virtual S VisitQueryContinuationClause(QueryContinuationClause queryContinuationClause, T data)
    {
      return VisitChildren (queryContinuationClause, data);
    }
    
    public virtual S VisitQueryFromClause(QueryFromClause queryFromClause, T data)
    {
      return VisitChildren (queryFromClause, data);
    }
    
    public virtual S VisitQueryLetClause(QueryLetClause queryLetClause, T data)
    {
      return VisitChildren (queryLetClause, data);
    }
    
    public virtual S VisitQueryWhereClause(QueryWhereClause queryWhereClause, T data)
    {
      return VisitChildren (queryWhereClause, data);
    }
    
    public virtual S VisitQueryJoinClause(QueryJoinClause queryJoinClause, T data)
    {
      return VisitChildren (queryJoinClause, data);
    }
    
    public virtual S VisitQueryOrderClause(QueryOrderClause queryOrderClause, T data)
    {
      return VisitChildren (queryOrderClause, data);
    }
    
    public virtual S VisitQueryOrdering(QueryOrdering queryOrdering, T data)
    {
      return VisitChildren (queryOrdering, data);
    }
    
    public virtual S VisitQuerySelectClause(QuerySelectClause querySelectClause, T data)
    {
      return VisitChildren (querySelectClause, data);
    }
    
    public virtual S VisitQueryGroupClause(QueryGroupClause queryGroupClause, T data)
    {
      return VisitChildren (queryGroupClause, data);
    }
    
    public virtual S VisitAsExpression (AsExpression asExpression, T data)
    {
      return VisitChildren (asExpression, data);
    }
    
    public virtual S VisitIsExpression (IsExpression isExpression, T data)
    {
      return VisitChildren (isExpression, data);
    }
    
    public virtual S VisitDefaultValueExpression (DefaultValueExpression defaultValueExpression, T data)
    {
      return VisitChildren (defaultValueExpression, data);
    }
    
    public virtual S VisitUndocumentedExpression (UndocumentedExpression undocumentedExpression, T data)
    {
      return VisitChildren (undocumentedExpression, data);
    }
    
    public virtual S VisitArrayInitializerExpression (ArrayInitializerExpression arrayInitializerExpression, T data)
    {
      return VisitChildren (arrayInitializerExpression, data);
    }
    
    public virtual S VisitArraySpecifier (ArraySpecifier arraySpecifier, T data)
    {
      return VisitChildren (arraySpecifier, data);
    }
    
    public virtual S VisitNamedArgumentExpression (NamedArgumentExpression namedArgumentExpression, T data)
    {
      return VisitChildren (namedArgumentExpression, data);
    }
    
    public virtual S VisitNamedExpression (NamedExpression namedExpression, T data)
    {
      return VisitChildren (namedExpression, data);
    }

    public virtual S VisitErrorNode(AstNode errorNode, T data)
    {
      return VisitChildren(errorNode, data);
    }

    public virtual S VisitPatternPlaceholder(AstNode placeholder, PatternMatching.Pattern pattern, T data)
    {
      return VisitChildren (placeholder, data);
    }
  }
}