/// <summary>
        /// Expands the specified macro.
        /// </summary>
        /// <param name="macro">The macro.</param>
        /// <returns></returns>
        public override Statement Expand(MacroStatement macro)
        {
            Property property = new Property(propertyName);
            property.LexicalInfo = macro.LexicalInfo;
            property.Getter = new Method();
            if(macro.Arguments.Count==1)
            {
                property.Getter.Body.Add(
                    new ReturnStatement(macro.Arguments[0])
                    );
            }
            else if(
                macro.Arguments.Count == 0 &&
                macro.Body != null &&
				macro.Body.IsEmpty == false)//use the macro block
            {
				property.Getter.Body = macro.Body;
            }
            else
            {
                CompilerErrorFactory.CustomError(macro.LexicalInfo,
                                                 macro.Name + " must have a single expression argument or a block");
                return null;
            }

            ClassDefinition clazz = (ClassDefinition) macro.GetAncestor(NodeType.ClassDefinition);
            clazz.Members.Add(property);

            return null;
        }

 protected static void PromoteExtensions(MacroStatement macro, MacroStatement parent)
 {
     ApplyExtensions(macro, delegate(Expression extension)
                 {
                     RegisterExtension(parent, extension);
                 });
 }

 public override void OnMacroStatement(MacroStatement node)
 {
     using (enter()){
         defaultProcess(node);
         base.OnMacroStatement(node);    
     }
 }

		public void MacroCompilerIsTakenFromTheEnvironment()
		{
			var compiler = new Mock<MacroCompiler>(MockBehavior.Strict);

			ActiveEnvironment.With(CompilerContextEnvironmentWith(compiler), ()=>
			{
				var module = CreateModule();
				var macroApplication = new MacroStatement(new LexicalInfo("file.boo", 1, 1), "foo");
				module.Globals.Add(macroApplication);

				var macroDefinition = CreateClassOn(module, "FooMacro");

				compiler.Setup(o => o.AlreadyCompiled(macroDefinition)).Returns(false);
				compiler.Setup(o => o.Compile(macroDefinition)).Returns((Type)null);

				var expander = My<MacroExpander>.Instance;
				Assert.IsFalse(expander.ExpandAll());

				var errors = CompilerErrors();
				Assert.AreEqual(1, errors.Count);
				Assert.AreEqual(CompilerErrorFactory.AstMacroMustBeExternal(macroApplication, (IType) macroDefinition.Entity).ToString(), errors[0].ToString());
			});

			compiler.VerifyAll();
		}

 private static void UnescapeInitialAndClosingDoubleQuotes(MacroStatement macro){
     var value = macro.Arguments[0] as StringLiteralExpression;
     if (value == null){
         return;
     }
     value.Value = BrailPreProcessor.UnescapeInitialAndClosingDoubleQuotes(value.Value);
 }

        protected override Statement ExpandImpl(MacroStatement macro){
            if (macro.Arguments.Count == 0){
                Context.Errors.Add(new CompilerError(macro.LexicalInfo,
                                                     "sub macro requires at least one reference or string attribute for subview name"));
            }

            var call = new MethodInvocationExpression(AstUtil.CreateReferenceExpression("OutputSubView"));
            int i = 0;
            foreach (Expression argument in macro.Arguments){
                i++;
                Expression exp = argument;
                if (i == 1){
//action and contrller parameters
                    if (argument is ReferenceExpression && !(argument is MemberReferenceExpression)){
                        if (argument.ToCodeString().StartsWith("@") || argument.ToCodeString().Contains(".")){
                            exp = AstUtil.CreateReferenceExpression(argument.ToCodeString().Substring(1));
                        }
                        else{
                            exp = new StringLiteralExpression(argument.ToCodeString());
                        }
                    }
                }
                call.Arguments.Add(exp);
            }
            return new ExpressionStatement(call);
        }

        void ExpandIncludeMacro(MacroStatement macro)
        {
            if (macro.Arguments.Count != 1)
                throw new ScriptParsingException("include requires a single literal string argument ('filename').");

            var include = macro.Arguments[0] as StringLiteralExpression;
            if (include == null)
                throw new ScriptParsingException("include argument should be a literal string ('filename').");

            var fullPath = Path.Combine(
                Path.GetDirectoryName(macro.LexicalInfo.FullPath),
                include.Value
                );

            var compiled = compiler.CompileInclude(fullPath).CompileUnit.Modules[0];

            var module = macro.GetAncestor<Module>();
            foreach (var import in compiled.Imports) {
                module.Imports.Add(import);
            }

            var type = macro.GetAncestor<TypeDefinition>();
            foreach (var member in compiled.Members) {
                type.Members.Add(member);
            }

            var parent = (Block) macro.ParentNode;
            var currentPosition = parent.Statements.IndexOf(macro);

            RemoveCurrentNode();
            foreach (var global in compiled.Globals.Statements.Reverse()) {
                parent.Insert(currentPosition, global);
            }
        }

            protected override Statement ExpandImpl(MacroStatement macro){
                string tagname = macro.Arguments[0].ToCodeString();

                
                bool useend = macro.Arguments.Contains(x=>x.ToCodeString()=="___end");
                bool usestart = macro.Arguments.Contains(x => x.ToCodeString() == "___start");
                bool wastagmodifiers = useend||usestart;
        
                if(!wastagmodifiers){
                    useend = true;
                    usestart = true;
                }

                IEnumerable<Expression> argsource = macro.Arguments.Skip(1).Where(x=>!(x.ToCodeString().StartsWith("___")));
                StatementCollection statements = macro.Body.Statements;
                
                
                Statement result = tryResolveTemplate(macro, tagname, argsource);
                if (null == result){

                    result = expandBmlElement(tagname, argsource, statements, usestart,useend);
                }
                return result;
            
            }

        /// <summary>
        /// Perform the actual expansion of the macro
        /// </summary>
        /// <param name="macro">The macro.</param>
        /// <returns></returns>
        protected override Statement DoExpand(MacroStatement macro)
        {
            if (macro.Arguments.Count != 0)
            {
                Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo,"No arguments allowed for action statement"));
                return null;
            }

            Method mergeRowsMethod = new Method("MergeRows");
            mergeRowsMethod.Modifiers = TypeMemberModifiers.Override;
            mergeRowsMethod.Parameters.Add(new ParameterDeclaration("left", new SimpleTypeReference(typeof(Row).FullName)));
            mergeRowsMethod.Parameters.Add(new ParameterDeclaration("right", new SimpleTypeReference(typeof(Row).FullName)));
            CodeBuilder.DeclareLocal(mergeRowsMethod, "row", TypeSystemServices.Map(typeof(Row)));
            mergeRowsMethod.Body.Add(
                new BinaryExpression(BinaryOperatorType.Assign,
                                     new ReferenceExpression("row"),
                                     new MethodInvocationExpression(
                                         AstUtil.CreateReferenceExpression(typeof(Row).FullName))
                    )
                );
            mergeRowsMethod.Body.Add(macro.Body);
            mergeRowsMethod.Body.Add(new ReturnStatement(new ReferenceExpression("row")));

            ParentMethods.Add(mergeRowsMethod);
            return null;
        }

        public override void OnMacroStatement(MacroStatement node)
        {
            base.OnMacroStatement(node);

            if (node.Name == "include")
                ExpandIncludeMacro(node);
        }

 protected override Statement ExpandImpl(MacroStatement macro){
     if (macro.Arguments.Count == 0){
         throw new Exception("output must be called with arguemnts");
     }
     UnescapeInitialAndClosingDoubleQuotes(macro);
     return PrintMacroModule.expandPrintMacro(macro, output, output);
 }

        /// <summary>
        /// Perform the actual expansion of the macro
        /// </summary>
        /// <param name="macro">The macro.</param>
        /// <returns></returns>
        protected override Statement DoExpand(MacroStatement macro)
        {
            List<string> columns = new List<string>();

            if(macro.Block.HasStatements)
            {
                Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo, "GroupBy cannot contain statements"));
                return null;
            }
            foreach (Expression argument in macro.Arguments)
            {
                ReferenceExpression expr = argument as ReferenceExpression;
                if(expr==null)
                {
                    Errors.Add(CompilerErrorFactory.CustomError(macro.LexicalInfo, "GroupBy arguments must be refernce expressions. Example: groupBy name, surname"));
                    return null;
                }
                columns.Add(expr.Name);
            }

            Method method = CreateGetColumnsToGroupByMethod(macro, columns);

            ParentMethods.Add(method);

            return null;
        }

        public void ForCoverage()
        {
            var statement = new MacroStatement();
            statement.Block.Statements.Add(new MacroStatement());

            CodeBuilderHelper.CreateCallableFromMacroBody(new BooCodeBuilder(new TypeSystemServices()), statement);
        }

        /// <summary>
        /// Expands the specified macro, validate that the parent is a valid parent, 
        /// leave the actual processing to a base class
        /// </summary>
        /// <param name="macro">The macro.</param>
        /// <returns></returns>
        public override Statement Expand(MacroStatement macro)
        {
            if (ValidateParent(macro, out parent) == false)
                return null;

            return DoExpand(macro);
        }

		public override Statement Expand(MacroStatement macro)
		{
			if (macro.Arguments.Count == 0)
				throw new RailsException("output must be called with arguemnts");
			UnescapeInitialAndClosingDoubleQuotes(macro);
			return Expand(macro, output, output);
		}

        protected override Statement ExpandImpl(MacroStatement macro){
            var result = new Block();
            foreach (Statement st in macro.Body.Statements){
                var decl = st as DeclarationStatement;
                var refer = st as ExpressionStatement;
                if(null==decl){
                    var ex = refer.Expression;
                    if (ex is MethodInvocationExpression){
                        decl =
                            new DeclarationStatement(
                                new Declaration(((MethodInvocationExpression) refer.Expression).Target.ToCodeString(),
                                                null), null);
                    }
                    if(ex is BinaryExpression){
                        var b = ex as BinaryExpression;
                        decl = new DeclarationStatement(
                            new Declaration(b.Left.ToCodeString(),null),b.Right
                            );
                    }
                }

                var bin = new BinaryExpression(BinaryOperatorType.Assign,
                                               new TryCastExpression(new ReferenceExpression(decl.Declaration.Name),
                                                                     decl.Declaration.Type),
                                               decl.Initializer);
                var def = new MacroStatement("definebrailproperty");
                def.Arguments.Add(bin);
                result.Add(def);
            }
            return result;
        }

 public override Statement Expand(MacroStatement macro)
 {
     var instance = macro.Arguments[0] as ReferenceExpression;
     var transformer = new WithExpander(instance);
     transformer.Visit(macro.Body);
     return macro.Body;
 }

 protected override IEnumerable<Node> ExpandGeneratorImpl(MacroStatement macro){
     var method = new Method("_key"){
                                        ReturnType = new SimpleTypeReference("string"),
                                        Modifiers = TypeMemberModifiers.Public | TypeMemberModifiers.Override,
                                        Body = macro.extractMethodBody()
                                    };
     yield return method;
 }

 protected override IEnumerable<Node> ExpandGeneratorImpl(MacroStatement macro){
     string typename = macro.Arguments[0].ToCodeString() + ", " + macro.Arguments[1].ToCodeString();
     //for normalizing nested classes parsed as add operators
     typename = typename.Replace(" ", "");
     var type = Type.GetType(typename);
     var generator = (IAstIncludeSource)type.GetConstructor(Type.EmptyTypes).Invoke(null);
     return generator.Substitute(macro);
 }

 protected override Statement ExpandImpl(MacroStatement macro){
     var call = new MethodInvocationExpression(
         new ReferenceExpression("__Export")
         );
     call.Arguments.Add(new StringLiteralExpression(macro.Arguments[0].ToCodeString()));
     if(macro.Arguments.Count==2){
         call.Arguments.Add(macro.Arguments[1]);
     }
     return new ExpressionStatement(call);
 }