public override void OnModule(Boo.Lang.Compiler.Ast.Module module)
 {
     EnterNamespace((INamespace)TypeSystemServices.GetEntity(module));
     Visit(module.Members);
     Visit(module.Globals);
     LeaveNamespace();
 }

        /// <summary>
        /// Called when visting a reference expression.
        /// Will turn reference expressions with initial @ to string literals
        /// </summary>
        /// <param name="node">The node.</param>
        public override void OnReferenceExpression(Boo.Lang.Compiler.Ast.ReferenceExpression node)
        {
            if(node.Name.StartsWith("@")==false)
                return;

            ReplaceCurrentNode(new StringLiteralExpression(node.Name.Substring(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);
			}
		}

        protected override void CustomizeCompiler(Boo.Lang.Compiler.BooCompiler compiler, Boo.Lang.Compiler.CompilerPipeline pipeline, string[] urls)
        {
            compiler.Parameters.Ducky = true;

            pipeline.Insert(1, new ImplicitBaseClassCompilerStep(
                _baseType, "Prepare", _namespaces));
        }

        protected override void CustomizeCompiler(Boo.Lang.Compiler.BooCompiler compiler, Boo.Lang.Compiler.CompilerPipeline pipeline, string[] urls)
        {
            compiler.Parameters.Ducky = true;

            List<Assembly> asmss = new List<Assembly>();
            if (RefAllLoadedAssemblies)
            {
                asmss.AddRange(AppDomain.CurrentDomain.GetAssemblies());
            }
            if (ReferencedAssemblies != null) asmss.AddRange(ReferencedAssemblies);

            foreach (Assembly asm in asmss)
            {
                try
                {
                    string loc = asm.Location;
                    if (!compiler.Parameters.References.Contains(asm)) compiler.Parameters.References.Add(asm);
                }
                catch (Exception) { log.Debug("Error adding assembly dependency: {0}", asm.FullName); }
            }

            pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(ScriptDSLBase), "Prepare", Namespaces));
            var st2 = new AutoReferenceFilesCompilerStep(_baseDir + "\\include");
            pipeline.Insert(2, st2);
        }

 /// <summary>
 /// Enters the module.
 /// </summary>
 /// <param name="node">The node.</param>
 /// <returns></returns>
 public override bool EnterModule(Boo.Lang.Compiler.Ast.Module node)
 {
     currentModule = node.Name;
     if (moduleNameToContainedTypes.ContainsKey(currentModule) == false)
         moduleNameToContainedTypes[currentModule] = new List<string>();
     return base.EnterModule(node);
 }

 public override void OnArrayTypeReference(Boo.Lang.Compiler.Ast.ArrayTypeReference node)
 {
     MethodInvocationExpression mie = new MethodInvocationExpression(
             node.LexicalInfo,
             CreateReference(node, "Boo.Lang.Compiler.Ast.ArrayTypeReference"));
     mie.Arguments.Add(Serialize(node.LexicalInfo));
     if (ShouldSerialize(node.IsPointer))
     {
         mie.NamedArguments.Add(
             new ExpressionPair(
                 CreateReference(node, "IsPointer"),
                 Serialize(node.IsPointer)));
     }
     if (ShouldSerialize(node.ElementType))
     {
         mie.NamedArguments.Add(
             new ExpressionPair(
                 CreateReference(node, "ElementType"),
                 Serialize(node.ElementType)));
     }
     if (ShouldSerialize(node.Rank))
     {
         mie.NamedArguments.Add(
             new ExpressionPair(
                 CreateReference(node, "Rank"),
                 Serialize(node.Rank)));
     }
     Push(mie);
 }

 public override void OnModule(Boo.Lang.Compiler.Ast.Module module)
 {
     EnterNamespace(InternalModule.ScopeFor(module));
     VisitTypeDefinitionBody(module);
     Visit(module.AssemblyAttributes);
     LeaveNamespace();
 }

 protected void reply_with_one_of(Boo.Lang.List replies)
 {
     var random = new Random();
     var indexToUse = random.Next(replies.Count);
     Console.WriteLine("replies.Count = {0}, using index {1}", replies.Count, indexToUse);
     reply(replies[indexToUse] as string);
 }

		public static WSABooParser CreateParser(int tabSize, string readerName, TextReader reader, Boo.Lang.Parser.ParserErrorHandler errorHandler)
		{
			var parser = new WSABooParser(CreateBooLexer(tabSize, readerName, reader));
			parser.setFilename(readerName);
			parser.Error += errorHandler;
			return parser;
		}

		public virtual void OnCompileUnit(Boo.Lang.Compiler.Ast.CompileUnit node)
		{				
			if (EnterCompileUnit(node))
			{
				Visit(node.Modules);
				LeaveCompileUnit(node);
			}
		}

 public static CompilerError AttributeApplicationError(Exception error, Boo.Lang.Compiler.Ast.Attribute attribute, Type attributeType)
 {
     return new CompilerError("BCE0009",
                               attribute.LexicalInfo,
                               error,
                               attributeType,
                               error.Message);
 }

		public override void LeaveEnumDefinition(Boo.Lang.Compiler.Ast.EnumDefinition node)
		{
			var designator=new StringBuilder();
			designator.Append("T:");
			designator.Append(node.FullName);
			this.ProcessDocumentation(designator.ToString(), node);
			base.LeaveEnumDefinition(node);
		}

 public static void Prepare(Boo.Lang.Compiler.Pipelines.Parse result)
 {
     if(-1!=result.Find(typeof(BooParsingStep))){
         result.InsertAfter(typeof (BooParsingStep), new IncludeAstMacroExpandStep());
     }else if (-1!=result.Find(typeof(WSABooParsingStep))){
         result.InsertAfter(typeof(WSABooParsingStep), new IncludeAstMacroExpandStep());
     }
 }

		public virtual void OnExplicitMemberInfo(Boo.Lang.Compiler.Ast.ExplicitMemberInfo node)
		{				
			if (EnterExplicitMemberInfo(node))
			{
				Visit(node.InterfaceType);
				LeaveExplicitMemberInfo(node);
			}
		}

		protected string GetDocumentation(Boo.Lang.Compiler.Ast.Module module)
		{
			string doc = module.Documentation;
			if (null == module.Documentation)
			{
				Assert.Fail(string.Format("Test case '{0}' does not have a docstring!", module.LexicalInfo.FileName));
			}
			return doc;
		}

		public virtual void OnTypeMemberStatement(Boo.Lang.Compiler.Ast.TypeMemberStatement node)
		{				
			if (EnterTypeMemberStatement(node))
			{
				Visit(node.Modifier);
				Visit(node.TypeMember);
				LeaveTypeMemberStatement(node);
			}
		}

        protected override void CustomizeCompiler(Boo.Lang.Compiler.BooCompiler compiler, Boo.Lang.Compiler.CompilerPipeline pipeline, string[] urls)
        {
            Logger log = LogManager.GetCurrentClassLogger();
            compiler.Parameters.Ducky = true;
            compiler.Parameters.Debug = true;

            

            pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(ProcessDefDSLBase), "Prepare", _namespaces));
        }

        public void AnotherUnflatTest()
        {
            var flat = new FlatBoo { Boo1Id = 5 };
            var boo = new Boo();

            boo.InjectFrom<UnflatLoopInjection>(flat);

            boo.Boo1Id.IsEqualTo(5);
            boo.Boo1.IsEqualTo(null);
        }

		void IAstVisitor.OnExplicitMemberInfo(Boo.Lang.Compiler.Ast.ExplicitMemberInfo node)
		{	
			{
				var interfaceType = node.InterfaceType;
				if (interfaceType != null)
					interfaceType.Accept(this);
			}
			var handler = OnExplicitMemberInfo;
			if (handler != null)
				handler(node);
		}