/src/Boo.Lang.Compiler/Ast/Impl/DepthFirstTransformer.cs

Large files files are truncated, but you can click here to view the full file

#region license
// Copyright (c) 2009 Rodrigo B. de Oliveira (rbo@acm.org)
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
// 
//     * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//     * Neither the name of Rodrigo B. de Oliveira nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion

//
// DO NOT EDIT THIS FILE!
//
// This file was generated automatically by astgen.boo.
//

namespace Boo.Lang.Compiler.Ast
{
	using System;

	public partial class DepthFirstTransformer : IAstVisitor
	{

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnCompileUnit(Boo.Lang.Compiler.Ast.CompileUnit node)
		{	
			if (EnterCompileUnit(node))
			{
				Visit(node.Modules);

				LeaveCompileUnit(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterCompileUnit(Boo.Lang.Compiler.Ast.CompileUnit node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveCompileUnit(Boo.Lang.Compiler.Ast.CompileUnit node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnTypeMemberStatement(Boo.Lang.Compiler.Ast.TypeMemberStatement node)
		{	
			if (EnterTypeMemberStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				TypeMember currentTypeMemberValue = node.TypeMember;
				if (null != currentTypeMemberValue)
				{			
					TypeMember newValue = (TypeMember)VisitNode(currentTypeMemberValue);
					if (!object.ReferenceEquals(newValue, currentTypeMemberValue))
					{
						node.TypeMember = newValue;
					}
				}

				LeaveTypeMemberStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterTypeMemberStatement(Boo.Lang.Compiler.Ast.TypeMemberStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveTypeMemberStatement(Boo.Lang.Compiler.Ast.TypeMemberStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnExplicitMemberInfo(Boo.Lang.Compiler.Ast.ExplicitMemberInfo node)
		{	
			if (EnterExplicitMemberInfo(node))
			{
				SimpleTypeReference currentInterfaceTypeValue = node.InterfaceType;
				if (null != currentInterfaceTypeValue)
				{			
					SimpleTypeReference newValue = (SimpleTypeReference)VisitNode(currentInterfaceTypeValue);
					if (!object.ReferenceEquals(newValue, currentInterfaceTypeValue))
					{
						node.InterfaceType = newValue;
					}
				}

				LeaveExplicitMemberInfo(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterExplicitMemberInfo(Boo.Lang.Compiler.Ast.ExplicitMemberInfo node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveExplicitMemberInfo(Boo.Lang.Compiler.Ast.ExplicitMemberInfo node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnSimpleTypeReference(Boo.Lang.Compiler.Ast.SimpleTypeReference node)
		{	
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnArrayTypeReference(Boo.Lang.Compiler.Ast.ArrayTypeReference node)
		{	
			if (EnterArrayTypeReference(node))
			{
				TypeReference currentElementTypeValue = node.ElementType;
				if (null != currentElementTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentElementTypeValue);
					if (!object.ReferenceEquals(newValue, currentElementTypeValue))
					{
						node.ElementType = newValue;
					}
				}
				IntegerLiteralExpression currentRankValue = node.Rank;
				if (null != currentRankValue)
				{			
					IntegerLiteralExpression newValue = (IntegerLiteralExpression)VisitNode(currentRankValue);
					if (!object.ReferenceEquals(newValue, currentRankValue))
					{
						node.Rank = newValue;
					}
				}

				LeaveArrayTypeReference(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterArrayTypeReference(Boo.Lang.Compiler.Ast.ArrayTypeReference node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveArrayTypeReference(Boo.Lang.Compiler.Ast.ArrayTypeReference node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnCallableTypeReference(Boo.Lang.Compiler.Ast.CallableTypeReference node)
		{	
			if (EnterCallableTypeReference(node))
			{
				Visit(node.Parameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}

				LeaveCallableTypeReference(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterCallableTypeReference(Boo.Lang.Compiler.Ast.CallableTypeReference node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveCallableTypeReference(Boo.Lang.Compiler.Ast.CallableTypeReference node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnGenericTypeReference(Boo.Lang.Compiler.Ast.GenericTypeReference node)
		{	
			if (EnterGenericTypeReference(node))
			{
				Visit(node.GenericArguments);

				LeaveGenericTypeReference(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterGenericTypeReference(Boo.Lang.Compiler.Ast.GenericTypeReference node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveGenericTypeReference(Boo.Lang.Compiler.Ast.GenericTypeReference node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnGenericTypeDefinitionReference(Boo.Lang.Compiler.Ast.GenericTypeDefinitionReference node)
		{	
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnCallableDefinition(Boo.Lang.Compiler.Ast.CallableDefinition node)
		{	
			if (EnterCallableDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);

				LeaveCallableDefinition(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterCallableDefinition(Boo.Lang.Compiler.Ast.CallableDefinition node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveCallableDefinition(Boo.Lang.Compiler.Ast.CallableDefinition node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnNamespaceDeclaration(Boo.Lang.Compiler.Ast.NamespaceDeclaration node)
		{	
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnImport(Boo.Lang.Compiler.Ast.Import node)
		{	
			if (EnterImport(node))
			{
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}
				ReferenceExpression currentAssemblyReferenceValue = node.AssemblyReference;
				if (null != currentAssemblyReferenceValue)
				{			
					ReferenceExpression newValue = (ReferenceExpression)VisitNode(currentAssemblyReferenceValue);
					if (!object.ReferenceEquals(newValue, currentAssemblyReferenceValue))
					{
						node.AssemblyReference = newValue;
					}
				}
				ReferenceExpression currentAliasValue = node.Alias;
				if (null != currentAliasValue)
				{			
					ReferenceExpression newValue = (ReferenceExpression)VisitNode(currentAliasValue);
					if (!object.ReferenceEquals(newValue, currentAliasValue))
					{
						node.Alias = newValue;
					}
				}

				LeaveImport(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterImport(Boo.Lang.Compiler.Ast.Import node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveImport(Boo.Lang.Compiler.Ast.Import node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnModule(Boo.Lang.Compiler.Ast.Module node)
		{	
			if (EnterModule(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);
				Visit(node.GenericParameters);
				NamespaceDeclaration currentNamespaceValue = node.Namespace;
				if (null != currentNamespaceValue)
				{			
					NamespaceDeclaration newValue = (NamespaceDeclaration)VisitNode(currentNamespaceValue);
					if (!object.ReferenceEquals(newValue, currentNamespaceValue))
					{
						node.Namespace = newValue;
					}
				}
				Visit(node.Imports);
				Block currentGlobalsValue = node.Globals;
				if (null != currentGlobalsValue)
				{			
					Block newValue = (Block)VisitNode(currentGlobalsValue);
					if (!object.ReferenceEquals(newValue, currentGlobalsValue))
					{
						node.Globals = newValue;
					}
				}
				Visit(node.AssemblyAttributes);

				LeaveModule(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterModule(Boo.Lang.Compiler.Ast.Module node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveModule(Boo.Lang.Compiler.Ast.Module node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnClassDefinition(Boo.Lang.Compiler.Ast.ClassDefinition node)
		{	
			if (EnterClassDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);
				Visit(node.GenericParameters);

				LeaveClassDefinition(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterClassDefinition(Boo.Lang.Compiler.Ast.ClassDefinition node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveClassDefinition(Boo.Lang.Compiler.Ast.ClassDefinition node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnStructDefinition(Boo.Lang.Compiler.Ast.StructDefinition node)
		{	
			if (EnterStructDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);
				Visit(node.GenericParameters);

				LeaveStructDefinition(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterStructDefinition(Boo.Lang.Compiler.Ast.StructDefinition node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveStructDefinition(Boo.Lang.Compiler.Ast.StructDefinition node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnInterfaceDefinition(Boo.Lang.Compiler.Ast.InterfaceDefinition node)
		{	
			if (EnterInterfaceDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);
				Visit(node.GenericParameters);

				LeaveInterfaceDefinition(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterInterfaceDefinition(Boo.Lang.Compiler.Ast.InterfaceDefinition node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveInterfaceDefinition(Boo.Lang.Compiler.Ast.InterfaceDefinition node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnEnumDefinition(Boo.Lang.Compiler.Ast.EnumDefinition node)
		{	
			if (EnterEnumDefinition(node))
			{
				Visit(node.Attributes);
				Visit(node.Members);
				Visit(node.BaseTypes);
				Visit(node.GenericParameters);

				LeaveEnumDefinition(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterEnumDefinition(Boo.Lang.Compiler.Ast.EnumDefinition node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveEnumDefinition(Boo.Lang.Compiler.Ast.EnumDefinition node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnEnumMember(Boo.Lang.Compiler.Ast.EnumMember node)
		{	
			if (EnterEnumMember(node))
			{
				Visit(node.Attributes);
				Expression currentInitializerValue = node.Initializer;
				if (null != currentInitializerValue)
				{			
					Expression newValue = (Expression)VisitNode(currentInitializerValue);
					if (!object.ReferenceEquals(newValue, currentInitializerValue))
					{
						node.Initializer = newValue;
					}
				}

				LeaveEnumMember(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterEnumMember(Boo.Lang.Compiler.Ast.EnumMember node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveEnumMember(Boo.Lang.Compiler.Ast.EnumMember node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnField(Boo.Lang.Compiler.Ast.Field node)
		{	
			if (EnterField(node))
			{
				Visit(node.Attributes);
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}
				Expression currentInitializerValue = node.Initializer;
				if (null != currentInitializerValue)
				{			
					Expression newValue = (Expression)VisitNode(currentInitializerValue);
					if (!object.ReferenceEquals(newValue, currentInitializerValue))
					{
						node.Initializer = newValue;
					}
				}

				LeaveField(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterField(Boo.Lang.Compiler.Ast.Field node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveField(Boo.Lang.Compiler.Ast.Field node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnProperty(Boo.Lang.Compiler.Ast.Property node)
		{	
			if (EnterProperty(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Method currentGetterValue = node.Getter;
				if (null != currentGetterValue)
				{			
					Method newValue = (Method)VisitNode(currentGetterValue);
					if (!object.ReferenceEquals(newValue, currentGetterValue))
					{
						node.Getter = newValue;
					}
				}
				Method currentSetterValue = node.Setter;
				if (null != currentSetterValue)
				{			
					Method newValue = (Method)VisitNode(currentSetterValue);
					if (!object.ReferenceEquals(newValue, currentSetterValue))
					{
						node.Setter = newValue;
					}
				}
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveProperty(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterProperty(Boo.Lang.Compiler.Ast.Property node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveProperty(Boo.Lang.Compiler.Ast.Property node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnEvent(Boo.Lang.Compiler.Ast.Event node)
		{	
			if (EnterEvent(node))
			{
				Visit(node.Attributes);
				Method currentAddValue = node.Add;
				if (null != currentAddValue)
				{			
					Method newValue = (Method)VisitNode(currentAddValue);
					if (!object.ReferenceEquals(newValue, currentAddValue))
					{
						node.Add = newValue;
					}
				}
				Method currentRemoveValue = node.Remove;
				if (null != currentRemoveValue)
				{			
					Method newValue = (Method)VisitNode(currentRemoveValue);
					if (!object.ReferenceEquals(newValue, currentRemoveValue))
					{
						node.Remove = newValue;
					}
				}
				Method currentRaiseValue = node.Raise;
				if (null != currentRaiseValue)
				{			
					Method newValue = (Method)VisitNode(currentRaiseValue);
					if (!object.ReferenceEquals(newValue, currentRaiseValue))
					{
						node.Raise = newValue;
					}
				}
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveEvent(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterEvent(Boo.Lang.Compiler.Ast.Event node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveEvent(Boo.Lang.Compiler.Ast.Event node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnLocal(Boo.Lang.Compiler.Ast.Local node)
		{	
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnBlockExpression(Boo.Lang.Compiler.Ast.BlockExpression node)
		{	
			if (EnterBlockExpression(node))
			{
				Visit(node.Parameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}

				LeaveBlockExpression(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterBlockExpression(Boo.Lang.Compiler.Ast.BlockExpression node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveBlockExpression(Boo.Lang.Compiler.Ast.BlockExpression node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnMethod(Boo.Lang.Compiler.Ast.Method node)
		{	
			if (EnterMethod(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}
				Visit(node.Locals);
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveMethod(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterMethod(Boo.Lang.Compiler.Ast.Method node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveMethod(Boo.Lang.Compiler.Ast.Method node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnConstructor(Boo.Lang.Compiler.Ast.Constructor node)
		{	
			if (EnterConstructor(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}
				Visit(node.Locals);
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveConstructor(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterConstructor(Boo.Lang.Compiler.Ast.Constructor node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveConstructor(Boo.Lang.Compiler.Ast.Constructor node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnDestructor(Boo.Lang.Compiler.Ast.Destructor node)
		{	
			if (EnterDestructor(node))
			{
				Visit(node.Attributes);
				Visit(node.Parameters);
				Visit(node.GenericParameters);
				TypeReference currentReturnTypeValue = node.ReturnType;
				if (null != currentReturnTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentReturnTypeValue);
					if (!object.ReferenceEquals(newValue, currentReturnTypeValue))
					{
						node.ReturnType = newValue;
					}
				}
				Visit(node.ReturnTypeAttributes);
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}
				Visit(node.Locals);
				ExplicitMemberInfo currentExplicitInfoValue = node.ExplicitInfo;
				if (null != currentExplicitInfoValue)
				{			
					ExplicitMemberInfo newValue = (ExplicitMemberInfo)VisitNode(currentExplicitInfoValue);
					if (!object.ReferenceEquals(newValue, currentExplicitInfoValue))
					{
						node.ExplicitInfo = newValue;
					}
				}

				LeaveDestructor(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterDestructor(Boo.Lang.Compiler.Ast.Destructor node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveDestructor(Boo.Lang.Compiler.Ast.Destructor node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnParameterDeclaration(Boo.Lang.Compiler.Ast.ParameterDeclaration node)
		{	
			if (EnterParameterDeclaration(node))
			{
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}
				Visit(node.Attributes);

				LeaveParameterDeclaration(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterParameterDeclaration(Boo.Lang.Compiler.Ast.ParameterDeclaration node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveParameterDeclaration(Boo.Lang.Compiler.Ast.ParameterDeclaration node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnGenericParameterDeclaration(Boo.Lang.Compiler.Ast.GenericParameterDeclaration node)
		{	
			if (EnterGenericParameterDeclaration(node))
			{
				Visit(node.BaseTypes);

				LeaveGenericParameterDeclaration(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterGenericParameterDeclaration(Boo.Lang.Compiler.Ast.GenericParameterDeclaration node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveGenericParameterDeclaration(Boo.Lang.Compiler.Ast.GenericParameterDeclaration node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnDeclaration(Boo.Lang.Compiler.Ast.Declaration node)
		{	
			if (EnterDeclaration(node))
			{
				TypeReference currentTypeValue = node.Type;
				if (null != currentTypeValue)
				{			
					TypeReference newValue = (TypeReference)VisitNode(currentTypeValue);
					if (!object.ReferenceEquals(newValue, currentTypeValue))
					{
						node.Type = newValue;
					}
				}

				LeaveDeclaration(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterDeclaration(Boo.Lang.Compiler.Ast.Declaration node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveDeclaration(Boo.Lang.Compiler.Ast.Declaration node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnAttribute(Boo.Lang.Compiler.Ast.Attribute node)
		{	
			if (EnterAttribute(node))
			{
				Visit(node.Arguments);
				Visit(node.NamedArguments);

				LeaveAttribute(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterAttribute(Boo.Lang.Compiler.Ast.Attribute node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveAttribute(Boo.Lang.Compiler.Ast.Attribute node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnStatementModifier(Boo.Lang.Compiler.Ast.StatementModifier node)
		{	
			if (EnterStatementModifier(node))
			{
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}

				LeaveStatementModifier(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterStatementModifier(Boo.Lang.Compiler.Ast.StatementModifier node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveStatementModifier(Boo.Lang.Compiler.Ast.StatementModifier node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnGotoStatement(Boo.Lang.Compiler.Ast.GotoStatement node)
		{	
			if (EnterGotoStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				ReferenceExpression currentLabelValue = node.Label;
				if (null != currentLabelValue)
				{			
					ReferenceExpression newValue = (ReferenceExpression)VisitNode(currentLabelValue);
					if (!object.ReferenceEquals(newValue, currentLabelValue))
					{
						node.Label = newValue;
					}
				}

				LeaveGotoStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterGotoStatement(Boo.Lang.Compiler.Ast.GotoStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveGotoStatement(Boo.Lang.Compiler.Ast.GotoStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnLabelStatement(Boo.Lang.Compiler.Ast.LabelStatement node)
		{	
			if (EnterLabelStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}

				LeaveLabelStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterLabelStatement(Boo.Lang.Compiler.Ast.LabelStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveLabelStatement(Boo.Lang.Compiler.Ast.LabelStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnBlock(Boo.Lang.Compiler.Ast.Block node)
		{	
			if (EnterBlock(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Visit(node.Statements);

				LeaveBlock(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterBlock(Boo.Lang.Compiler.Ast.Block node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveBlock(Boo.Lang.Compiler.Ast.Block node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnDeclarationStatement(Boo.Lang.Compiler.Ast.DeclarationStatement node)
		{	
			if (EnterDeclarationStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Declaration currentDeclarationValue = node.Declaration;
				if (null != currentDeclarationValue)
				{			
					Declaration newValue = (Declaration)VisitNode(currentDeclarationValue);
					if (!object.ReferenceEquals(newValue, currentDeclarationValue))
					{
						node.Declaration = newValue;
					}
				}
				Expression currentInitializerValue = node.Initializer;
				if (null != currentInitializerValue)
				{			
					Expression newValue = (Expression)VisitNode(currentInitializerValue);
					if (!object.ReferenceEquals(newValue, currentInitializerValue))
					{
						node.Initializer = newValue;
					}
				}

				LeaveDeclarationStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterDeclarationStatement(Boo.Lang.Compiler.Ast.DeclarationStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveDeclarationStatement(Boo.Lang.Compiler.Ast.DeclarationStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnMacroStatement(Boo.Lang.Compiler.Ast.MacroStatement node)
		{	
			if (EnterMacroStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Visit(node.Arguments);
				Block currentBodyValue = node.Body;
				if (null != currentBodyValue)
				{			
					Block newValue = (Block)VisitNode(currentBodyValue);
					if (!object.ReferenceEquals(newValue, currentBodyValue))
					{
						node.Body = newValue;
					}
				}

				LeaveMacroStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterMacroStatement(Boo.Lang.Compiler.Ast.MacroStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveMacroStatement(Boo.Lang.Compiler.Ast.MacroStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnTryStatement(Boo.Lang.Compiler.Ast.TryStatement node)
		{	
			if (EnterTryStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Block currentProtectedBlockValue = node.ProtectedBlock;
				if (null != currentProtectedBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentProtectedBlockValue);
					if (!object.ReferenceEquals(newValue, currentProtectedBlockValue))
					{
						node.ProtectedBlock = newValue;
					}
				}
				Visit(node.ExceptionHandlers);
				Block currentFailureBlockValue = node.FailureBlock;
				if (null != currentFailureBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentFailureBlockValue);
					if (!object.ReferenceEquals(newValue, currentFailureBlockValue))
					{
						node.FailureBlock = newValue;
					}
				}
				Block currentEnsureBlockValue = node.EnsureBlock;
				if (null != currentEnsureBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentEnsureBlockValue);
					if (!object.ReferenceEquals(newValue, currentEnsureBlockValue))
					{
						node.EnsureBlock = newValue;
					}
				}

				LeaveTryStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterTryStatement(Boo.Lang.Compiler.Ast.TryStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveTryStatement(Boo.Lang.Compiler.Ast.TryStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnExceptionHandler(Boo.Lang.Compiler.Ast.ExceptionHandler node)
		{	
			if (EnterExceptionHandler(node))
			{
				Declaration currentDeclarationValue = node.Declaration;
				if (null != currentDeclarationValue)
				{			
					Declaration newValue = (Declaration)VisitNode(currentDeclarationValue);
					if (!object.ReferenceEquals(newValue, currentDeclarationValue))
					{
						node.Declaration = newValue;
					}
				}
				Expression currentFilterConditionValue = node.FilterCondition;
				if (null != currentFilterConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentFilterConditionValue);
					if (!object.ReferenceEquals(newValue, currentFilterConditionValue))
					{
						node.FilterCondition = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}

				LeaveExceptionHandler(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterExceptionHandler(Boo.Lang.Compiler.Ast.ExceptionHandler node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveExceptionHandler(Boo.Lang.Compiler.Ast.ExceptionHandler node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnIfStatement(Boo.Lang.Compiler.Ast.IfStatement node)
		{	
			if (EnterIfStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}
				Block currentTrueBlockValue = node.TrueBlock;
				if (null != currentTrueBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentTrueBlockValue);
					if (!object.ReferenceEquals(newValue, currentTrueBlockValue))
					{
						node.TrueBlock = newValue;
					}
				}
				Block currentFalseBlockValue = node.FalseBlock;
				if (null != currentFalseBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentFalseBlockValue);
					if (!object.ReferenceEquals(newValue, currentFalseBlockValue))
					{
						node.FalseBlock = newValue;
					}
				}

				LeaveIfStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterIfStatement(Boo.Lang.Compiler.Ast.IfStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveIfStatement(Boo.Lang.Compiler.Ast.IfStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnUnlessStatement(Boo.Lang.Compiler.Ast.UnlessStatement node)
		{	
			if (EnterUnlessStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}

				LeaveUnlessStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterUnlessStatement(Boo.Lang.Compiler.Ast.UnlessStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveUnlessStatement(Boo.Lang.Compiler.Ast.UnlessStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnForStatement(Boo.Lang.Compiler.Ast.ForStatement node)
		{	
			if (EnterForStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Visit(node.Declarations);
				Expression currentIteratorValue = node.Iterator;
				if (null != currentIteratorValue)
				{			
					Expression newValue = (Expression)VisitNode(currentIteratorValue);
					if (!object.ReferenceEquals(newValue, currentIteratorValue))
					{
						node.Iterator = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}
				Block currentOrBlockValue = node.OrBlock;
				if (null != currentOrBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentOrBlockValue);
					if (!object.ReferenceEquals(newValue, currentOrBlockValue))
					{
						node.OrBlock = newValue;
					}
				}
				Block currentThenBlockValue = node.ThenBlock;
				if (null != currentThenBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentThenBlockValue);
					if (!object.ReferenceEquals(newValue, currentThenBlockValue))
					{
						node.ThenBlock = newValue;
					}
				}

				LeaveForStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterForStatement(Boo.Lang.Compiler.Ast.ForStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveForStatement(Boo.Lang.Compiler.Ast.ForStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnWhileStatement(Boo.Lang.Compiler.Ast.WhileStatement node)
		{	
			if (EnterWhileStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentConditionValue = node.Condition;
				if (null != currentConditionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentConditionValue);
					if (!object.ReferenceEquals(newValue, currentConditionValue))
					{
						node.Condition = newValue;
					}
				}
				Block currentBlockValue = node.Block;
				if (null != currentBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentBlockValue);
					if (!object.ReferenceEquals(newValue, currentBlockValue))
					{
						node.Block = newValue;
					}
				}
				Block currentOrBlockValue = node.OrBlock;
				if (null != currentOrBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentOrBlockValue);
					if (!object.ReferenceEquals(newValue, currentOrBlockValue))
					{
						node.OrBlock = newValue;
					}
				}
				Block currentThenBlockValue = node.ThenBlock;
				if (null != currentThenBlockValue)
				{			
					Block newValue = (Block)VisitNode(currentThenBlockValue);
					if (!object.ReferenceEquals(newValue, currentThenBlockValue))
					{
						node.ThenBlock = newValue;
					}
				}

				LeaveWhileStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterWhileStatement(Boo.Lang.Compiler.Ast.WhileStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveWhileStatement(Boo.Lang.Compiler.Ast.WhileStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnBreakStatement(Boo.Lang.Compiler.Ast.BreakStatement node)
		{	
			if (EnterBreakStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}

				LeaveBreakStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterBreakStatement(Boo.Lang.Compiler.Ast.BreakStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveBreakStatement(Boo.Lang.Compiler.Ast.BreakStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnContinueStatement(Boo.Lang.Compiler.Ast.ContinueStatement node)
		{	
			if (EnterContinueStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}

				LeaveContinueStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterContinueStatement(Boo.Lang.Compiler.Ast.ContinueStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveContinueStatement(Boo.Lang.Compiler.Ast.ContinueStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnReturnStatement(Boo.Lang.Compiler.Ast.ReturnStatement node)
		{	
			if (EnterReturnStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue);
					if (!object.ReferenceEquals(newValue, currentExpressionValue))
					{
						node.Expression = newValue;
					}
				}

				LeaveReturnStatement(node);
			}
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual bool EnterReturnStatement(Boo.Lang.Compiler.Ast.ReturnStatement node)
		{
			return true;
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void LeaveReturnStatement(Boo.Lang.Compiler.Ast.ReturnStatement node)
		{
		}

		[System.CodeDom.Compiler.GeneratedCodeAttribute("astgen.boo", "1")]
		public virtual void OnYieldStatement(Boo.Lang.Compiler.Ast.YieldStatement node)
		{	
			if (EnterYieldStatement(node))
			{
				StatementModifier currentModifierValue = node.Modifier;
				if (null != currentModifierValue)
				{			
					StatementModifier newValue = (StatementModifier)VisitNode(currentModifierValue);
					if (!object.ReferenceEquals(newValue, currentModifierValue))
					{
						node.Modifier = newValue;
					}
				}
				Expression currentExpressionValue = node.Expression;
				if (null != currentExpressionValue)
				{			
					Expression newValue = (Expression)VisitNode(currentExpressionValue)…