nodetrackingastvisitor.cs

根据cs源码解析为codedom

			object result = this.TrackedVisit(sizeOfExpression, data);
			this.EndVisit(sizeOfExpression);
			return result;
		}
		
		public sealed override object VisitStackAllocExpression(StackAllocExpression stackAllocExpression, object data) {
			this.BeginVisit(stackAllocExpression);
			object result = this.TrackedVisit(stackAllocExpression, data);
			this.EndVisit(stackAllocExpression);
			return result;
		}
		
		public sealed override object VisitStopStatement(StopStatement stopStatement, object data) {
			this.BeginVisit(stopStatement);
			object result = this.TrackedVisit(stopStatement, data);
			this.EndVisit(stopStatement);
			return result;
		}
		
		public sealed override object VisitSwitchSection(SwitchSection switchSection, object data) {
			this.BeginVisit(switchSection);
			object result = this.TrackedVisit(switchSection, data);
			this.EndVisit(switchSection);
			return result;
		}
		
		public sealed override object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
			this.BeginVisit(switchStatement);
			object result = this.TrackedVisit(switchStatement, data);
			this.EndVisit(switchStatement);
			return result;
		}
		
		public sealed override object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
			this.BeginVisit(templateDefinition);
			object result = this.TrackedVisit(templateDefinition, data);
			this.EndVisit(templateDefinition);
			return result;
		}
		
		public sealed override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
			this.BeginVisit(thisReferenceExpression);
			object result = this.TrackedVisit(thisReferenceExpression, data);
			this.EndVisit(thisReferenceExpression);
			return result;
		}
		
		public sealed override object VisitThrowStatement(ThrowStatement throwStatement, object data) {
			this.BeginVisit(throwStatement);
			object result = this.TrackedVisit(throwStatement, data);
			this.EndVisit(throwStatement);
			return result;
		}
		
		public sealed override object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
			this.BeginVisit(tryCatchStatement);
			object result = this.TrackedVisit(tryCatchStatement, data);
			this.EndVisit(tryCatchStatement);
			return result;
		}
		
		public sealed override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
			this.BeginVisit(typeDeclaration);
			object result = this.TrackedVisit(typeDeclaration, data);
			this.EndVisit(typeDeclaration);
			return result;
		}
		
		public sealed override object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
			this.BeginVisit(typeOfExpression);
			object result = this.TrackedVisit(typeOfExpression, data);
			this.EndVisit(typeOfExpression);
			return result;
		}
		
		public sealed override object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
			this.BeginVisit(typeOfIsExpression);
			object result = this.TrackedVisit(typeOfIsExpression, data);
			this.EndVisit(typeOfIsExpression);
			return result;
		}
		
		public sealed override object VisitTypeReference(TypeReference typeReference, object data) {
			this.BeginVisit(typeReference);
			object result = this.TrackedVisit(typeReference, data);
			this.EndVisit(typeReference);
			return result;
		}
		
		public sealed override object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
			this.BeginVisit(typeReferenceExpression);
			object result = this.TrackedVisit(typeReferenceExpression, data);
			this.EndVisit(typeReferenceExpression);
			return result;
		}
		
		public sealed override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
			this.BeginVisit(unaryOperatorExpression);
			object result = this.TrackedVisit(unaryOperatorExpression, data);
			this.EndVisit(unaryOperatorExpression);
			return result;
		}
		
		public sealed override object VisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data) {
			this.BeginVisit(uncheckedExpression);
			object result = this.TrackedVisit(uncheckedExpression, data);
			this.EndVisit(uncheckedExpression);
			return result;
		}
		
		public sealed override object VisitUncheckedStatement(UncheckedStatement uncheckedStatement, object data) {
			this.BeginVisit(uncheckedStatement);
			object result = this.TrackedVisit(uncheckedStatement, data);
			this.EndVisit(uncheckedStatement);
			return result;
		}
		
		public sealed override object VisitUnsafeStatement(UnsafeStatement unsafeStatement, object data) {
			this.BeginVisit(unsafeStatement);
			object result = this.TrackedVisit(unsafeStatement, data);
			this.EndVisit(unsafeStatement);
			return result;
		}
		
		public sealed override object VisitUsing(Using @using, object data) {
			this.BeginVisit(@using);
			object result = this.TrackedVisit(@using, data);
			this.EndVisit(@using);
			return result;
		}
		
		public sealed override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
			this.BeginVisit(usingDeclaration);
			object result = this.TrackedVisit(usingDeclaration, data);
			this.EndVisit(usingDeclaration);
			return result;
		}
		
		public sealed override object VisitUsingStatement(UsingStatement usingStatement, object data) {
			this.BeginVisit(usingStatement);
			object result = this.TrackedVisit(usingStatement, data);
			this.EndVisit(usingStatement);
			return result;
		}
		
		public sealed override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
			this.BeginVisit(variableDeclaration);
			object result = this.TrackedVisit(variableDeclaration, data);
			this.EndVisit(variableDeclaration);
			return result;
		}
		
		public sealed override object VisitWithStatement(WithStatement withStatement, object data) {
			this.BeginVisit(withStatement);
			object result = this.TrackedVisit(withStatement, data);
			this.EndVisit(withStatement);
			return result;
		}
		
		public sealed override object VisitYieldStatement(YieldStatement yieldStatement, object data) {
			this.BeginVisit(yieldStatement);
			object result = this.TrackedVisit(yieldStatement, data);
			this.EndVisit(yieldStatement);
			return result;
		}
		
		public virtual object TrackedVisit(AddHandlerStatement addHandlerStatement, object data) {
			return base.VisitAddHandlerStatement(addHandlerStatement, data);
		}
		
		public virtual object TrackedVisit(AddressOfExpression addressOfExpression, object data) {
			return base.VisitAddressOfExpression(addressOfExpression, data);
		}
		
		public virtual object TrackedVisit(AnonymousMethodExpression anonymousMethodExpression, object data) {
			return base.VisitAnonymousMethodExpression(anonymousMethodExpression, data);
		}
		
		public virtual object TrackedVisit(ArrayCreateExpression arrayCreateExpression, object data) {
			return base.VisitArrayCreateExpression(arrayCreateExpression, data);
		}
		
		public virtual object TrackedVisit(ArrayInitializerExpression arrayInitializerExpression, object data) {
			return base.VisitArrayInitializerExpression(arrayInitializerExpression, data);
		}
		
		public virtual object TrackedVisit(AssignmentExpression assignmentExpression, object data) {
			return base.VisitAssignmentExpression(assignmentExpression, data);
		}
		
		public virtual object TrackedVisit(ICSharpCode.NRefactory.Ast.Attribute attribute, object data) {
			return base.VisitAttribute(attribute, data);
		}
		
		public virtual object TrackedVisit(AttributeSection attributeSection, object data) {
			return base.VisitAttributeSection(attributeSection, data);
		}
		
		public virtual object TrackedVisit(BaseReferenceExpression baseReferenceExpression, object data) {
			return base.VisitBaseReferenceExpression(baseReferenceExpression, data);
		}
		
		public virtual object TrackedVisit(BinaryOperatorExpression binaryOperatorExpression, object data) {
			return base.VisitBinaryOperatorExpression(binaryOperatorExpression, data);
		}
		
		public virtual object TrackedVisit(BlockStatement blockStatement, object data) {
			return base.VisitBlockStatement(blockStatement, data);
		}
		
		public virtual object TrackedVisit(BreakStatement breakStatement, object data) {
			return base.VisitBreakStatement(breakStatement, data);
		}
		
		public virtual object TrackedVisit(CaseLabel caseLabel, object data) {
			return base.VisitCaseLabel(caseLabel, data);
		}
		
		public virtual object TrackedVisit(CastExpression castExpression, object data) {
			return base.VisitCastExpression(castExpression, data);
		}
		
		public virtual object TrackedVisit(CatchClause catchClause, object data) {
			return base.VisitCatchClause(catchClause, data);
		}
		
		public virtual object TrackedVisit(CheckedExpression checkedExpression, object data) {
			return base.VisitCheckedExpression(checkedExpression, data);
		}
		
		public virtual object TrackedVisit(CheckedStatement checkedStatement, object data) {
			return base.VisitCheckedStatement(checkedStatement, data);
		}
		
		public virtual object TrackedVisit(ClassReferenceExpression classReferenceExpression, object data) {
			return base.VisitClassReferenceExpression(classReferenceExpression, data);
		}
		
		public virtual object TrackedVisit(CompilationUnit compilationUnit, object data) {
			return base.VisitCompilationUnit(compilationUnit, data);
		}
		
		public virtual object TrackedVisit(ConditionalExpression conditionalExpression, object data) {
			return base.VisitConditionalExpression(conditionalExpression, data);
		}
		
		public virtual object TrackedVisit(ConstructorDeclaration constructorDeclaration, object data) {
			return base.VisitConstructorDeclaration(constructorDeclaration, data);
		}
		
		public virtual object TrackedVisit(ConstructorInitializer constructorInitializer, object data) {
			return base.VisitConstructorInitializer(constructorInitializer, data);
		}
		
		public virtual object TrackedVisit(ContinueStatement continueStatement, object data) {
			return base.VisitContinueStatement(continueStatement, data);
		}
		
		public virtual object TrackedVisit(DeclareDeclaration declareDeclaration, object data) {
			return base.VisitDeclareDeclaration(declareDeclaration, data);
		}
		
		public virtual object TrackedVisit(DefaultValueExpression defaultValueExpression, object data) {
			return base.VisitDefaultValueExpression(defaultValueExpression, data);
		}
		
		public virtual object TrackedVisit(DelegateDeclaration delegateDeclaration, object data) {
			return base.VisitDelegateDeclaration(delegateDeclaration, data);
		}
		
		public virtual object TrackedVisit(DestructorDeclaration destructorDeclaration, object data) {
			return base.VisitDestructorDeclaration(destructorDeclaration, data);
		}
		
		public virtual object TrackedVisit(DirectionExpression directionExpression, object data) {
			return base.VisitDirectionExpression(directionExpression, data);
		}
		
		public virtual object TrackedVisit(DoLoopStatement doLoopStatement, object data) {
			return base.VisitDoLoopStatement(doLoopStatement, data);
		}
		
		public virtual object TrackedVisit(ElseIfSection elseIfSection, object data) {
			return base.VisitElseIfSection(elseIfSection, data);
		}
		
		public virtual object TrackedVisit(EmptyStatement emptyStatement, object data) {