diff --git a/src/AddIns/Misc/ResourceToolkit/Project/ResourceToolkit.csproj b/src/AddIns/Misc/ResourceToolkit/Project/ResourceToolkit.csproj index 2c2c0740ba..fd792bbd04 100644 --- a/src/AddIns/Misc/ResourceToolkit/Project/ResourceToolkit.csproj +++ b/src/AddIns/Misc/ResourceToolkit/Project/ResourceToolkit.csproj @@ -63,7 +63,6 @@ - diff --git a/src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/PositionTrackingAstVisitor.cs b/src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/PositionTrackingAstVisitor.cs index 562e55579e..f2b5b80b1f 100644 --- a/src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/PositionTrackingAstVisitor.cs +++ b/src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/PositionTrackingAstVisitor.cs @@ -21,7 +21,7 @@ namespace Hornung.ResourceToolkit.Resolver /// Provides contextual position information while iterating through /// the AST and the ability to resolve expressions in-place. /// - public abstract class PositionTrackingAstVisitor : NodeTrackingAstVisitor + public abstract class PositionTrackingAstVisitor : ICSharpCode.NRefactory.Visitors.NodeTrackingAstVisitor { private Stack parentNodes; diff --git a/src/Libraries/NRefactory/NRefactory.sln b/src/Libraries/NRefactory/NRefactory.sln index c4939974b6..9bde0d8af4 100644 --- a/src/Libraries/NRefactory/NRefactory.sln +++ b/src/Libraries/NRefactory/NRefactory.sln @@ -1,5 +1,5 @@ Microsoft Visual Studio Solution File, Format Version 9.00 -# SharpDevelop 2.1.0.1602 +# SharpDevelop 2.1.0.1865 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactory", "Project\NRefactory.csproj", "{3A9AE6AA-BC07-4A2F-972C-581E3AE2F195}" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NRefactoryTests", "Test\NRefactoryTests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}" diff --git a/src/Libraries/NRefactory/NRefactoryASTGenerator/Main.cs b/src/Libraries/NRefactory/NRefactoryASTGenerator/Main.cs index 515af80986..8022342842 100644 --- a/src/Libraries/NRefactory/NRefactoryASTGenerator/Main.cs +++ b/src/Libraries/NRefactory/NRefactoryASTGenerator/Main.cs @@ -136,6 +136,20 @@ namespace NRefactoryASTGenerator new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings); File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", writer.ToString()); } + + ccu = new CodeCompileUnit(); + cns = new CodeNamespace("ICSharpCode.NRefactory.Visitors"); + ccu.Namespaces.Add(cns); + cns.Imports.Add(new CodeNamespaceImport("System")); + cns.Imports.Add(new CodeNamespaceImport("ICSharpCode.NRefactory.Ast")); + cns.Types.Add(CreateNodeTrackingAstVisitorClass(nodeTypes)); + + using (StringWriter writer = new StringWriter()) { + new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings); + // CodeDom cannot output "sealed", so we need to use this hack: + File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs", + writer.ToString().Replace("public override object", "public sealed override object")); + } } static CodeTypeDeclaration CreateAstVisitorInterface(List nodeTypes) @@ -497,5 +511,76 @@ namespace NRefactoryASTGenerator return new CodeTypeReference(type); } } + + static CodeTypeDeclaration CreateNodeTrackingAstVisitorClass(List nodeTypes) + { + CodeTypeDeclaration td = new CodeTypeDeclaration("NodeTrackingAstVisitor"); + td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Abstract; + td.BaseTypes.Add(new CodeTypeReference("AbstractAstVisitor")); + + string comment = "\n " + + "The NodeTrackingAstVisitor will iterate through the whole AST,\n " + + "just like the AbstractAstVisitor, and calls the virtual methods\n " + + "BeginVisit and EndVisit for each node being visited.\n " + + ""; + td.Comments.Add(new CodeCommentStatement(comment, true)); + comment = "\n " + + "base.Visit(node, data) calls this.TrackedVisit(node, data), so if\n " + + "you want to visit child nodes using the default visiting behaviour,\n " + + "use base.TrackedVisit(parentNode, data).\n " + + ""; + td.Comments.Add(new CodeCommentStatement(comment, true)); + + CodeMemberMethod m = new CodeMemberMethod(); + m.Name = "BeginVisit"; + m.Attributes = MemberAttributes.Family; + m.Parameters.Add(new CodeParameterDeclarationExpression("INode", "node")); + td.Members.Add(m); + + m = new CodeMemberMethod(); + m.Name = "EndVisit"; + m.Attributes = MemberAttributes.Family; + m.Parameters.Add(new CodeParameterDeclarationExpression("INode", "node")); + td.Members.Add(m); + + foreach (Type type in nodeTypes) { + if (!type.IsAbstract) { + + m = new CodeMemberMethod(); + m.Name = VisitPrefix + type.Name; + m.Attributes = MemberAttributes.Public | MemberAttributes.Override; + m.ReturnType = new CodeTypeReference(typeof(object)); + m.Parameters.Add(new CodeParameterDeclarationExpression(ConvertType(type), GetFieldName(type.Name))); + m.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), "data")); + td.Members.Add(m); + + CodeVariableReferenceExpression var = new CodeVariableReferenceExpression(GetFieldName(type.Name)); + + m.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "BeginVisit"), new CodeExpression[] { var })); + m.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference(typeof(object)), "result", new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "TrackedVisit"), new CodeExpression[] { var, new CodeVariableReferenceExpression("data") }))); + m.Statements.Add(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), "EndVisit"), new CodeExpression[] { var })); + m.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("result"))); + + } + } + + foreach (Type type in nodeTypes) { + if (!type.IsAbstract) { + + m = new CodeMemberMethod(); + m.Name = "TrackedVisit"; + m.Attributes = MemberAttributes.Public; + m.ReturnType = new CodeTypeReference(typeof(object)); + m.Parameters.Add(new CodeParameterDeclarationExpression(ConvertType(type), GetFieldName(type.Name))); + m.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), "data")); + td.Members.Add(m); + + m.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeBaseReferenceExpression(), VisitPrefix + type.Name), new CodeExpression[] { new CodeVariableReferenceExpression(GetFieldName(type.Name)), new CodeVariableReferenceExpression("data") }))); + + } + } + + return td; + } } } diff --git a/src/Libraries/NRefactory/Project/NRefactory.csproj b/src/Libraries/NRefactory/Project/NRefactory.csproj index dc5d6c14a2..3e132da3ae 100644 --- a/src/Libraries/NRefactory/Project/NRefactory.csproj +++ b/src/Libraries/NRefactory/Project/NRefactory.csproj @@ -122,6 +122,7 @@ + diff --git a/src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/NodeTrackingAstVisitor.cs b/src/Libraries/NRefactory/Project/Src/Visitors/NodeTrackingAstVisitor.cs similarity index 75% rename from src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/NodeTrackingAstVisitor.cs rename to src/Libraries/NRefactory/Project/Src/Visitors/NodeTrackingAstVisitor.cs index 3e3443b1a5..c6781ce474 100644 --- a/src/AddIns/Misc/ResourceToolkit/Project/Src/Resolver/NodeTrackingAstVisitor.cs +++ b/src/Libraries/NRefactory/Project/Src/Visitors/NodeTrackingAstVisitor.cs @@ -8,7 +8,7 @@ // //------------------------------------------------------------------------------ -namespace Hornung.ResourceToolkit.Resolver { +namespace ICSharpCode.NRefactory.Visitors { using System; using ICSharpCode.NRefactory.Ast; @@ -19,10 +19,11 @@ namespace Hornung.ResourceToolkit.Resolver { /// BeginVisit and EndVisit for each node being visited. /// /// - /// To enable the tracking functionality, you must override - /// the TrackedVisit methods instead of the Visit methods! + /// base.Visit(node, data) calls this.TrackedVisit(node, data), so if + /// you want to visit child nodes using the default visiting behaviour, + /// use base.TrackedVisit(parentNode, data). /// - public abstract class NodeTrackingAstVisitor : ICSharpCode.NRefactory.Visitors.AbstractAstVisitor { + public abstract class NodeTrackingAstVisitor : AbstractAstVisitor { protected virtual void BeginVisit(INode node) { } @@ -30,707 +31,707 @@ namespace Hornung.ResourceToolkit.Resolver { protected virtual void EndVisit(INode node) { } - public override object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) { + public sealed override object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) { this.BeginVisit(addHandlerStatement); object result = this.TrackedVisit(addHandlerStatement, data); this.EndVisit(addHandlerStatement); return result; } - public override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) { + public sealed override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) { this.BeginVisit(addressOfExpression); object result = this.TrackedVisit(addressOfExpression, data); this.EndVisit(addressOfExpression); return result; } - public override object VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data) { + public sealed override object VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data) { this.BeginVisit(anonymousMethodExpression); object result = this.TrackedVisit(anonymousMethodExpression, data); this.EndVisit(anonymousMethodExpression); return result; } - public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { + public sealed override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) { this.BeginVisit(arrayCreateExpression); object result = this.TrackedVisit(arrayCreateExpression, data); this.EndVisit(arrayCreateExpression); return result; } - public override object VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression, object data) { + public sealed override object VisitArrayInitializerExpression(ArrayInitializerExpression arrayInitializerExpression, object data) { this.BeginVisit(arrayInitializerExpression); object result = this.TrackedVisit(arrayInitializerExpression, data); this.EndVisit(arrayInitializerExpression); return result; } - public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { + public sealed override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { this.BeginVisit(assignmentExpression); object result = this.TrackedVisit(assignmentExpression, data); this.EndVisit(assignmentExpression); return result; } - public override object VisitAttribute(ICSharpCode.NRefactory.Ast.Attribute attribute, object data) { + public sealed override object VisitAttribute(ICSharpCode.NRefactory.Ast.Attribute attribute, object data) { this.BeginVisit(attribute); object result = this.TrackedVisit(attribute, data); this.EndVisit(attribute); return result; } - public override object VisitAttributeSection(AttributeSection attributeSection, object data) { + public sealed override object VisitAttributeSection(AttributeSection attributeSection, object data) { this.BeginVisit(attributeSection); object result = this.TrackedVisit(attributeSection, data); this.EndVisit(attributeSection); return result; } - public override object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) { + public sealed override object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) { this.BeginVisit(baseReferenceExpression); object result = this.TrackedVisit(baseReferenceExpression, data); this.EndVisit(baseReferenceExpression); return result; } - public override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) { + public sealed override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) { this.BeginVisit(binaryOperatorExpression); object result = this.TrackedVisit(binaryOperatorExpression, data); this.EndVisit(binaryOperatorExpression); return result; } - public override object VisitBlockStatement(BlockStatement blockStatement, object data) { + public sealed override object VisitBlockStatement(BlockStatement blockStatement, object data) { this.BeginVisit(blockStatement); object result = this.TrackedVisit(blockStatement, data); this.EndVisit(blockStatement); return result; } - public override object VisitBreakStatement(BreakStatement breakStatement, object data) { + public sealed override object VisitBreakStatement(BreakStatement breakStatement, object data) { this.BeginVisit(breakStatement); object result = this.TrackedVisit(breakStatement, data); this.EndVisit(breakStatement); return result; } - public override object VisitCaseLabel(CaseLabel caseLabel, object data) { + public sealed override object VisitCaseLabel(CaseLabel caseLabel, object data) { this.BeginVisit(caseLabel); object result = this.TrackedVisit(caseLabel, data); this.EndVisit(caseLabel); return result; } - public override object VisitCastExpression(CastExpression castExpression, object data) { + public sealed override object VisitCastExpression(CastExpression castExpression, object data) { this.BeginVisit(castExpression); object result = this.TrackedVisit(castExpression, data); this.EndVisit(castExpression); return result; } - public override object VisitCatchClause(CatchClause catchClause, object data) { + public sealed override object VisitCatchClause(CatchClause catchClause, object data) { this.BeginVisit(catchClause); object result = this.TrackedVisit(catchClause, data); this.EndVisit(catchClause); return result; } - public override object VisitCheckedExpression(CheckedExpression checkedExpression, object data) { + public sealed override object VisitCheckedExpression(CheckedExpression checkedExpression, object data) { this.BeginVisit(checkedExpression); object result = this.TrackedVisit(checkedExpression, data); this.EndVisit(checkedExpression); return result; } - public override object VisitCheckedStatement(CheckedStatement checkedStatement, object data) { + public sealed override object VisitCheckedStatement(CheckedStatement checkedStatement, object data) { this.BeginVisit(checkedStatement); object result = this.TrackedVisit(checkedStatement, data); this.EndVisit(checkedStatement); return result; } - public override object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) { + public sealed override object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) { this.BeginVisit(classReferenceExpression); object result = this.TrackedVisit(classReferenceExpression, data); this.EndVisit(classReferenceExpression); return result; } - public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data) { + public sealed override object VisitCompilationUnit(CompilationUnit compilationUnit, object data) { this.BeginVisit(compilationUnit); object result = this.TrackedVisit(compilationUnit, data); this.EndVisit(compilationUnit); return result; } - public override object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) { + public sealed override object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) { this.BeginVisit(conditionalExpression); object result = this.TrackedVisit(conditionalExpression, data); this.EndVisit(conditionalExpression); return result; } - public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) { + public sealed override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) { this.BeginVisit(constructorDeclaration); object result = this.TrackedVisit(constructorDeclaration, data); this.EndVisit(constructorDeclaration); return result; } - public override object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) { + public sealed override object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) { this.BeginVisit(constructorInitializer); object result = this.TrackedVisit(constructorInitializer, data); this.EndVisit(constructorInitializer); return result; } - public override object VisitContinueStatement(ContinueStatement continueStatement, object data) { + public sealed override object VisitContinueStatement(ContinueStatement continueStatement, object data) { this.BeginVisit(continueStatement); object result = this.TrackedVisit(continueStatement, data); this.EndVisit(continueStatement); return result; } - public override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) { + public sealed override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) { this.BeginVisit(declareDeclaration); object result = this.TrackedVisit(declareDeclaration, data); this.EndVisit(declareDeclaration); return result; } - public override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) { + public sealed override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) { this.BeginVisit(defaultValueExpression); object result = this.TrackedVisit(defaultValueExpression, data); this.EndVisit(defaultValueExpression); return result; } - public override object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) { + public sealed override object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) { this.BeginVisit(delegateDeclaration); object result = this.TrackedVisit(delegateDeclaration, data); this.EndVisit(delegateDeclaration); return result; } - public override object VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data) { + public sealed override object VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data) { this.BeginVisit(destructorDeclaration); object result = this.TrackedVisit(destructorDeclaration, data); this.EndVisit(destructorDeclaration); return result; } - public override object VisitDirectionExpression(DirectionExpression directionExpression, object data) { + public sealed override object VisitDirectionExpression(DirectionExpression directionExpression, object data) { this.BeginVisit(directionExpression); object result = this.TrackedVisit(directionExpression, data); this.EndVisit(directionExpression); return result; } - public override object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) { + public sealed override object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) { this.BeginVisit(doLoopStatement); object result = this.TrackedVisit(doLoopStatement, data); this.EndVisit(doLoopStatement); return result; } - public override object VisitElseIfSection(ElseIfSection elseIfSection, object data) { + public sealed override object VisitElseIfSection(ElseIfSection elseIfSection, object data) { this.BeginVisit(elseIfSection); object result = this.TrackedVisit(elseIfSection, data); this.EndVisit(elseIfSection); return result; } - public override object VisitEmptyStatement(EmptyStatement emptyStatement, object data) { + public sealed override object VisitEmptyStatement(EmptyStatement emptyStatement, object data) { this.BeginVisit(emptyStatement); object result = this.TrackedVisit(emptyStatement, data); this.EndVisit(emptyStatement); return result; } - public override object VisitEndStatement(EndStatement endStatement, object data) { + public sealed override object VisitEndStatement(EndStatement endStatement, object data) { this.BeginVisit(endStatement); object result = this.TrackedVisit(endStatement, data); this.EndVisit(endStatement); return result; } - public override object VisitEraseStatement(EraseStatement eraseStatement, object data) { + public sealed override object VisitEraseStatement(EraseStatement eraseStatement, object data) { this.BeginVisit(eraseStatement); object result = this.TrackedVisit(eraseStatement, data); this.EndVisit(eraseStatement); return result; } - public override object VisitErrorStatement(ErrorStatement errorStatement, object data) { + public sealed override object VisitErrorStatement(ErrorStatement errorStatement, object data) { this.BeginVisit(errorStatement); object result = this.TrackedVisit(errorStatement, data); this.EndVisit(errorStatement); return result; } - public override object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) { + public sealed override object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) { this.BeginVisit(eventAddRegion); object result = this.TrackedVisit(eventAddRegion, data); this.EndVisit(eventAddRegion); return result; } - public override object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) { + public sealed override object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) { this.BeginVisit(eventDeclaration); object result = this.TrackedVisit(eventDeclaration, data); this.EndVisit(eventDeclaration); return result; } - public override object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) { + public sealed override object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) { this.BeginVisit(eventRaiseRegion); object result = this.TrackedVisit(eventRaiseRegion, data); this.EndVisit(eventRaiseRegion); return result; } - public override object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) { + public sealed override object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) { this.BeginVisit(eventRemoveRegion); object result = this.TrackedVisit(eventRemoveRegion, data); this.EndVisit(eventRemoveRegion); return result; } - public override object VisitExitStatement(ExitStatement exitStatement, object data) { + public sealed override object VisitExitStatement(ExitStatement exitStatement, object data) { this.BeginVisit(exitStatement); object result = this.TrackedVisit(exitStatement, data); this.EndVisit(exitStatement); return result; } - public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) { + public sealed override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) { this.BeginVisit(expressionStatement); object result = this.TrackedVisit(expressionStatement, data); this.EndVisit(expressionStatement); return result; } - public override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) { + public sealed override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) { this.BeginVisit(fieldDeclaration); object result = this.TrackedVisit(fieldDeclaration, data); this.EndVisit(fieldDeclaration); return result; } - public override object VisitFieldReferenceExpression(FieldReferenceExpression fieldReferenceExpression, object data) { + public sealed override object VisitFieldReferenceExpression(FieldReferenceExpression fieldReferenceExpression, object data) { this.BeginVisit(fieldReferenceExpression); object result = this.TrackedVisit(fieldReferenceExpression, data); this.EndVisit(fieldReferenceExpression); return result; } - public override object VisitFixedStatement(FixedStatement fixedStatement, object data) { + public sealed override object VisitFixedStatement(FixedStatement fixedStatement, object data) { this.BeginVisit(fixedStatement); object result = this.TrackedVisit(fixedStatement, data); this.EndVisit(fixedStatement); return result; } - public override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { + public sealed override object VisitForeachStatement(ForeachStatement foreachStatement, object data) { this.BeginVisit(foreachStatement); object result = this.TrackedVisit(foreachStatement, data); this.EndVisit(foreachStatement); return result; } - public override object VisitForNextStatement(ForNextStatement forNextStatement, object data) { + public sealed override object VisitForNextStatement(ForNextStatement forNextStatement, object data) { this.BeginVisit(forNextStatement); object result = this.TrackedVisit(forNextStatement, data); this.EndVisit(forNextStatement); return result; } - public override object VisitForStatement(ForStatement forStatement, object data) { + public sealed override object VisitForStatement(ForStatement forStatement, object data) { this.BeginVisit(forStatement); object result = this.TrackedVisit(forStatement, data); this.EndVisit(forStatement); return result; } - public override object VisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement, object data) { + public sealed override object VisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement, object data) { this.BeginVisit(gotoCaseStatement); object result = this.TrackedVisit(gotoCaseStatement, data); this.EndVisit(gotoCaseStatement); return result; } - public override object VisitGotoStatement(GotoStatement gotoStatement, object data) { + public sealed override object VisitGotoStatement(GotoStatement gotoStatement, object data) { this.BeginVisit(gotoStatement); object result = this.TrackedVisit(gotoStatement, data); this.EndVisit(gotoStatement); return result; } - public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) { + public sealed override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) { this.BeginVisit(identifierExpression); object result = this.TrackedVisit(identifierExpression, data); this.EndVisit(identifierExpression); return result; } - public override object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) { + public sealed override object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) { this.BeginVisit(ifElseStatement); object result = this.TrackedVisit(ifElseStatement, data); this.EndVisit(ifElseStatement); return result; } - public override object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data) { + public sealed override object VisitIndexerDeclaration(IndexerDeclaration indexerDeclaration, object data) { this.BeginVisit(indexerDeclaration); object result = this.TrackedVisit(indexerDeclaration, data); this.EndVisit(indexerDeclaration); return result; } - public override object VisitIndexerExpression(IndexerExpression indexerExpression, object data) { + public sealed override object VisitIndexerExpression(IndexerExpression indexerExpression, object data) { this.BeginVisit(indexerExpression); object result = this.TrackedVisit(indexerExpression, data); this.EndVisit(indexerExpression); return result; } - public override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) { + public sealed override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) { this.BeginVisit(innerClassTypeReference); object result = this.TrackedVisit(innerClassTypeReference, data); this.EndVisit(innerClassTypeReference); return result; } - public override object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) { + public sealed override object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) { this.BeginVisit(interfaceImplementation); object result = this.TrackedVisit(interfaceImplementation, data); this.EndVisit(interfaceImplementation); return result; } - public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data) { + public sealed override object VisitInvocationExpression(InvocationExpression invocationExpression, object data) { this.BeginVisit(invocationExpression); object result = this.TrackedVisit(invocationExpression, data); this.EndVisit(invocationExpression); return result; } - public override object VisitLabelStatement(LabelStatement labelStatement, object data) { + public sealed override object VisitLabelStatement(LabelStatement labelStatement, object data) { this.BeginVisit(labelStatement); object result = this.TrackedVisit(labelStatement, data); this.EndVisit(labelStatement); return result; } - public override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) { + public sealed override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) { this.BeginVisit(localVariableDeclaration); object result = this.TrackedVisit(localVariableDeclaration, data); this.EndVisit(localVariableDeclaration); return result; } - public override object VisitLockStatement(LockStatement lockStatement, object data) { + public sealed override object VisitLockStatement(LockStatement lockStatement, object data) { this.BeginVisit(lockStatement); object result = this.TrackedVisit(lockStatement, data); this.EndVisit(lockStatement); return result; } - public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { + public sealed override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { this.BeginVisit(methodDeclaration); object result = this.TrackedVisit(methodDeclaration, data); this.EndVisit(methodDeclaration); return result; } - public override object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) { + public sealed override object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) { this.BeginVisit(namedArgumentExpression); object result = this.TrackedVisit(namedArgumentExpression, data); this.EndVisit(namedArgumentExpression); return result; } - public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) { + public sealed override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) { this.BeginVisit(namespaceDeclaration); object result = this.TrackedVisit(namespaceDeclaration, data); this.EndVisit(namespaceDeclaration); return result; } - public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) { + public sealed override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) { this.BeginVisit(objectCreateExpression); object result = this.TrackedVisit(objectCreateExpression, data); this.EndVisit(objectCreateExpression); return result; } - public override object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) { + public sealed override object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) { this.BeginVisit(onErrorStatement); object result = this.TrackedVisit(onErrorStatement, data); this.EndVisit(onErrorStatement); return result; } - public override object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) { + public sealed override object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) { this.BeginVisit(operatorDeclaration); object result = this.TrackedVisit(operatorDeclaration, data); this.EndVisit(operatorDeclaration); return result; } - public override object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) { + public sealed override object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) { this.BeginVisit(optionDeclaration); object result = this.TrackedVisit(optionDeclaration, data); this.EndVisit(optionDeclaration); return result; } - public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { + public sealed override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) { this.BeginVisit(parameterDeclarationExpression); object result = this.TrackedVisit(parameterDeclarationExpression, data); this.EndVisit(parameterDeclarationExpression); return result; } - public override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) { + public sealed override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) { this.BeginVisit(parenthesizedExpression); object result = this.TrackedVisit(parenthesizedExpression, data); this.EndVisit(parenthesizedExpression); return result; } - public override object VisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, object data) { + public sealed override object VisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, object data) { this.BeginVisit(pointerReferenceExpression); object result = this.TrackedVisit(pointerReferenceExpression, data); this.EndVisit(pointerReferenceExpression); return result; } - public override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) { + public sealed override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) { this.BeginVisit(primitiveExpression); object result = this.TrackedVisit(primitiveExpression, data); this.EndVisit(primitiveExpression); return result; } - public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) { + public sealed override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) { this.BeginVisit(propertyDeclaration); object result = this.TrackedVisit(propertyDeclaration, data); this.EndVisit(propertyDeclaration); return result; } - public override object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) { + public sealed override object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) { this.BeginVisit(propertyGetRegion); object result = this.TrackedVisit(propertyGetRegion, data); this.EndVisit(propertyGetRegion); return result; } - public override object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) { + public sealed override object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) { this.BeginVisit(propertySetRegion); object result = this.TrackedVisit(propertySetRegion, data); this.EndVisit(propertySetRegion); return result; } - public override object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) { + public sealed override object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) { this.BeginVisit(raiseEventStatement); object result = this.TrackedVisit(raiseEventStatement, data); this.EndVisit(raiseEventStatement); return result; } - public override object VisitReDimStatement(ReDimStatement reDimStatement, object data) { + public sealed override object VisitReDimStatement(ReDimStatement reDimStatement, object data) { this.BeginVisit(reDimStatement); object result = this.TrackedVisit(reDimStatement, data); this.EndVisit(reDimStatement); return result; } - public override object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) { + public sealed override object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) { this.BeginVisit(removeHandlerStatement); object result = this.TrackedVisit(removeHandlerStatement, data); this.EndVisit(removeHandlerStatement); return result; } - public override object VisitResumeStatement(ResumeStatement resumeStatement, object data) { + public sealed override object VisitResumeStatement(ResumeStatement resumeStatement, object data) { this.BeginVisit(resumeStatement); object result = this.TrackedVisit(resumeStatement, data); this.EndVisit(resumeStatement); return result; } - public override object VisitReturnStatement(ReturnStatement returnStatement, object data) { + public sealed override object VisitReturnStatement(ReturnStatement returnStatement, object data) { this.BeginVisit(returnStatement); object result = this.TrackedVisit(returnStatement, data); this.EndVisit(returnStatement); return result; } - public override object VisitSizeOfExpression(SizeOfExpression sizeOfExpression, object data) { + public sealed override object VisitSizeOfExpression(SizeOfExpression sizeOfExpression, object data) { this.BeginVisit(sizeOfExpression); object result = this.TrackedVisit(sizeOfExpression, data); this.EndVisit(sizeOfExpression); return result; } - public override object VisitStackAllocExpression(StackAllocExpression stackAllocExpression, object data) { + public sealed override object VisitStackAllocExpression(StackAllocExpression stackAllocExpression, object data) { this.BeginVisit(stackAllocExpression); object result = this.TrackedVisit(stackAllocExpression, data); this.EndVisit(stackAllocExpression); return result; } - public override object VisitStopStatement(StopStatement stopStatement, object data) { + public sealed override object VisitStopStatement(StopStatement stopStatement, object data) { this.BeginVisit(stopStatement); object result = this.TrackedVisit(stopStatement, data); this.EndVisit(stopStatement); return result; } - public override object VisitSwitchSection(SwitchSection switchSection, object data) { + public sealed override object VisitSwitchSection(SwitchSection switchSection, object data) { this.BeginVisit(switchSection); object result = this.TrackedVisit(switchSection, data); this.EndVisit(switchSection); return result; } - public override object VisitSwitchStatement(SwitchStatement switchStatement, object data) { + public sealed override object VisitSwitchStatement(SwitchStatement switchStatement, object data) { this.BeginVisit(switchStatement); object result = this.TrackedVisit(switchStatement, data); this.EndVisit(switchStatement); return result; } - public override object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) { + public sealed override object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) { this.BeginVisit(templateDefinition); object result = this.TrackedVisit(templateDefinition, data); this.EndVisit(templateDefinition); return result; } - public override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) { + public sealed override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) { this.BeginVisit(thisReferenceExpression); object result = this.TrackedVisit(thisReferenceExpression, data); this.EndVisit(thisReferenceExpression); return result; } - public override object VisitThrowStatement(ThrowStatement throwStatement, object data) { + public sealed override object VisitThrowStatement(ThrowStatement throwStatement, object data) { this.BeginVisit(throwStatement); object result = this.TrackedVisit(throwStatement, data); this.EndVisit(throwStatement); return result; } - public override object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) { + public sealed override object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) { this.BeginVisit(tryCatchStatement); object result = this.TrackedVisit(tryCatchStatement, data); this.EndVisit(tryCatchStatement); return result; } - public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) { + public sealed override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) { this.BeginVisit(typeDeclaration); object result = this.TrackedVisit(typeDeclaration, data); this.EndVisit(typeDeclaration); return result; } - public override object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) { + public sealed override object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) { this.BeginVisit(typeOfExpression); object result = this.TrackedVisit(typeOfExpression, data); this.EndVisit(typeOfExpression); return result; } - public override object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) { + public sealed override object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) { this.BeginVisit(typeOfIsExpression); object result = this.TrackedVisit(typeOfIsExpression, data); this.EndVisit(typeOfIsExpression); return result; } - public override object VisitTypeReference(TypeReference typeReference, object data) { + public sealed override object VisitTypeReference(TypeReference typeReference, object data) { this.BeginVisit(typeReference); object result = this.TrackedVisit(typeReference, data); this.EndVisit(typeReference); return result; } - public override object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) { + public sealed override object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) { this.BeginVisit(typeReferenceExpression); object result = this.TrackedVisit(typeReferenceExpression, data); this.EndVisit(typeReferenceExpression); return result; } - public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) { + public sealed override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) { this.BeginVisit(unaryOperatorExpression); object result = this.TrackedVisit(unaryOperatorExpression, data); this.EndVisit(unaryOperatorExpression); return result; } - public override object VisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data) { + public sealed override object VisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data) { this.BeginVisit(uncheckedExpression); object result = this.TrackedVisit(uncheckedExpression, data); this.EndVisit(uncheckedExpression); return result; } - public override object VisitUncheckedStatement(UncheckedStatement uncheckedStatement, object data) { + public sealed override object VisitUncheckedStatement(UncheckedStatement uncheckedStatement, object data) { this.BeginVisit(uncheckedStatement); object result = this.TrackedVisit(uncheckedStatement, data); this.EndVisit(uncheckedStatement); return result; } - public override object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) { + public sealed override object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) { this.BeginVisit(unsafeStatement); object result = this.TrackedVisit(unsafeStatement, data); this.EndVisit(unsafeStatement); return result; } - public override object VisitUsing(Using @using, object data) { + public sealed override object VisitUsing(Using @using, object data) { this.BeginVisit(@using); object result = this.TrackedVisit(@using, data); this.EndVisit(@using); return result; } - public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { + public sealed override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) { this.BeginVisit(usingDeclaration); object result = this.TrackedVisit(usingDeclaration, data); this.EndVisit(usingDeclaration); return result; } - public override object VisitUsingStatement(UsingStatement usingStatement, object data) { + public sealed override object VisitUsingStatement(UsingStatement usingStatement, object data) { this.BeginVisit(usingStatement); object result = this.TrackedVisit(usingStatement, data); this.EndVisit(usingStatement); return result; } - public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) { + public sealed override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) { this.BeginVisit(variableDeclaration); object result = this.TrackedVisit(variableDeclaration, data); this.EndVisit(variableDeclaration); return result; } - public override object VisitWithStatement(WithStatement withStatement, object data) { + public sealed override object VisitWithStatement(WithStatement withStatement, object data) { this.BeginVisit(withStatement); object result = this.TrackedVisit(withStatement, data); this.EndVisit(withStatement); return result; } - public override object VisitYieldStatement(YieldStatement yieldStatement, object data) { + public sealed override object VisitYieldStatement(YieldStatement yieldStatement, object data) { this.BeginVisit(yieldStatement); object result = this.TrackedVisit(yieldStatement, data); this.EndVisit(yieldStatement);