%%%-------------------------------------------------------------------
%%% File:      erlydtl_compiler.erl
%%% @author    Roberto Saccon <rsaccon@gmail.com> [http://rsaccon.com]
%%% @author    Evan Miller <emmiller@gmail.com>
%%% @copyright 2008 Roberto Saccon, Evan Miller
%%% @doc  
%%% ErlyDTL template compiler
%%% @end  
%%%
%%% The MIT License
%%%
%%% Copyright (c) 2007 Roberto Saccon, Evan Miller
%%%
%%% Permission is hereby granted, free of charge, to any person obtaining a copy
%%% of this software and associated documentation files (the "Software"), to deal
%%% in the Software without restriction, including without limitation the rights
%%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
%%% copies of the Software, and to permit persons to whom the Software is
%%% furnished to do so, subject to the following conditions:
%%%
%%% The above copyright notice and this permission notice shall be included in
%%% all copies or substantial portions of the Software.
%%%
%%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
%%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
%%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
%%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
%%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
%%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
%%% THE SOFTWARE.
%%%
%%% @since 2007-12-16 by Roberto Saccon, Evan Miller
%%%
%%%-------------------------------------------------------------------
%%% Adapted and expanded for Zotonic by Marc Worrell <marc@worrell.nl>
%%%-------------------------------------------------------------------

-module(erlydtl_compiler).
-author('rsaccon@gmail.com').
-author('emmiller@gmail.com').
-author('marc@worrell.nl').

-include_lib("zotonic.hrl").

%% --------------------------------------------------------------------
%% Definitions
%% --------------------------------------------------------------------
-export([compile/3, compile/4, compile/5, parse/1]).

-record(dtl_context, {
    local_scopes = [], 
    block_dict = dict:new(), 
    auto_escape = off, 
    parse_trail = [],
    extends_trail = [],
    block_trail = [],
    vars = [],
    custom_tags_dir = [],
    reader = {file, read_file},
    finder = undefined,
    module = [],
    compiler_options = [verbose, report_errors],
    force_recompile = false,
    z_context = undefined}).

-record(ast_info, {
    dependencies = [],
    var_names = [],
    pre_render_asts = []}).
    
-record(treewalker, {
    counter = 0,
    has_auto_id = false,
    custom_tags = []}).    

compile(Binary, Module, ZContext) when is_binary(Binary) ->
    compile(Binary, Module, [], ZContext);

compile(File, Module, ZContext) ->
    compile(File, File, Module, [], ZContext).

compile(Binary, Module, Options, ZContext) when is_binary(Binary) ->
    compile(Binary, [], Module, Options, ZContext);
    
compile(File, Module, Options, ZContext) ->  
    compile(File, filename:basename(File), Module, Options, ZContext).

compile(Binary, BaseFile, Module, Options, ZContext) when is_binary(Binary) ->
    TemplateResetCounter =  proplists:get_value(template_reset_counter, Options, 0),
    case parse(Binary) of
        {ok, DjangoParseTree} ->
            case compile_to_binary( BaseFile,
                                    DjangoParseTree, 
                                    init_dtl_context(BaseFile, BaseFile, Module, Options, ZContext),
                                    TemplateResetCounter) of
                {ok, Module1, _Bin} ->
                    {ok, Module1};
                Err ->
                    Err
            end;
        Err ->
            Err
    end;

compile(File, BaseFile, Module, Options, ZContext) ->  
    Context = init_dtl_context(File, BaseFile, Module, Options, ZContext),
    TemplateResetCounter =  proplists:get_value(template_reset_counter, Options, 0),
    case parse(File, Context) of  
        {ok, DjangoParseTree} ->
            case compile_to_binary(File, DjangoParseTree, Context, TemplateResetCounter) of
                {ok, Module1, _Bin} ->
                    {ok, Module1};
                Err ->
                    Err
            end;
        {error, {ErrLoc, ErrModule, ["syntax error before: " = ErrMsg, [$[,Text,$]]]}} when is_list(Text) ->
            Text1 = [ list_to_integer(C) || C <- Text, is_list(C) ],
            {error, {ErrLoc, ErrModule, ErrMsg ++ Text1}};
        {error, {ErrLoc, ErrModule, ErrMsg}} ->
            {error, {ErrLoc, ErrModule, lists:flatten(ErrMsg)}};
        Err ->
            Err
    end.
    

%%====================================================================
%% Internal functions
%%====================================================================

compile_to_binary(File, DjangoParseTree, Context, TemplateResetCounter) ->
    try body_ast(DjangoParseTree, Context, #treewalker{}) of
        {{Ast, Info}, TreeWalker} ->
            case compile:forms(forms(File, Context#dtl_context.module, Ast, Info, Context, TreeWalker, TemplateResetCounter), 
                    Context#dtl_context.compiler_options) of
                {ok, Module1, Bin} -> 
                    code:purge(Module1),
                    case code:load_binary(Module1, atom_to_list(Module1) ++ ".erl", Bin) of
                        {module, _} -> {ok, Module1, Bin};
                        _ -> {error, lists:concat(["code reload failed: ", Module1])}
                    end;
                error ->
                    {error, lists:concat(["compilation failed: ", File])};
                OtherError ->
                    OtherError
            end
    catch 
        throw:Error -> Error
    end.


init_dtl_context(File, BaseFile, Module, Options, ZContext) when is_list(Module) ->
    init_dtl_context(File, BaseFile, list_to_atom(Module), Options, ZContext);
init_dtl_context(File, BaseFile, Module, Options, ZContext) ->
    Ctx = #dtl_context{},
    #dtl_context{
        local_scopes = [ [{'$autoid', erl_syntax:variable("AutoId_"++z_ids:identifier())}] ],
        parse_trail = [File], 
        extends_trail = [BaseFile],
        module = Module,
        custom_tags_dir = proplists:get_value(custom_tags_dir, Options, Ctx#dtl_context.custom_tags_dir),
        vars = proplists:get_value(vars, Options, Ctx#dtl_context.vars), 
        reader = proplists:get_value(reader, Options, Ctx#dtl_context.reader),
        finder = proplists:get_value(finder, Options, Ctx#dtl_context.finder),
        compiler_options = proplists:get_value(compiler_options, Options, Ctx#dtl_context.compiler_options),
        force_recompile = proplists:get_value(force_recompile, Options, Ctx#dtl_context.force_recompile),
        z_context = ZContext}.   
    
parse(File, Context) ->  
    {M,F} = Context#dtl_context.reader,
    case catch M:F(File) of
        {ok, Data} ->
            case scan_parse(File, Data) of
                {ok, Val} ->
                    {ok, Val};
                Err ->
                    Err
            end;
        Error ->
            {error, io_lib:format("reading ~p failed (~p)", [File, Error])}  
    end.

% Used for parsing tests
parse(Data) when is_binary(Data) ->
    scan_parse("string", Data).

scan_parse(SourceRef, Data) ->
    case erlydtl_scanner:scan(SourceRef, binary_to_list(Data)) of
        {ok, Tokens} ->
            erlydtl_parser:parse(Tokens);
        Err ->
            Err
    end.        
  
forms(File, Module, BodyAst, BodyInfo, Context, TreeWalker, TemplateResetCounter) ->
    TemplateResetCounterFunctionAst = erl_syntax:function(
        erl_syntax:atom(template_reset_counter),
            [ erl_syntax:clause(
                    [],
                    none,
                    [erl_syntax:integer(TemplateResetCounter)]
                    )
            ]),

    TransTableFunctionAst = erl_syntax:function(
        erl_syntax:atom(trans_table),
            [ erl_syntax:clause(
                    [],
                    none,
                    [erl_syntax:abstract(z_trans_server:table(Context#dtl_context.z_context))]
                    )
            ]),

    Function2 = erl_syntax:application(none, erl_syntax:atom(render2), 
        [erl_syntax:variable("Variables"), erl_syntax:variable("ZpContext")]),
    ClauseOk = erl_syntax:clause([erl_syntax:variable("Val")], none,
        [erl_syntax:tuple([erl_syntax:atom(ok), erl_syntax:variable("Val")])]),     
    ClauseCatch = erl_syntax:clause([erl_syntax:variable("Err")], none,
        [erl_syntax:tuple([erl_syntax:atom(error), erl_syntax:variable("Err")])]),            
    Render2FunctionAst = erl_syntax:function(erl_syntax:atom(render),
        [erl_syntax:clause([erl_syntax:variable("Variables"), erl_syntax:variable("ZpContext")], none, 
            [erl_syntax:try_expr([Function2], [ClauseOk], [ClauseCatch])])]),  
     
    SourceFunctionAst = erl_syntax:function(
        erl_syntax:atom(source),
            [ erl_syntax:clause([], none, [ erl_syntax:string(File) ]) ]),

    Dependencies  = lists:usort([{File, filelib:last_modified(File)} | BodyInfo#ast_info.dependencies]),
    Dependencies1 = lists:filter(fun({[],0}) -> false; (_) -> true end, Dependencies),
    DependenciesFunctionAst = erl_syntax:function(
        erl_syntax:atom(dependencies), [
                erl_syntax:clause([], none, 
                    [ erl_syntax:list( lists:map(
                            fun ({XFile, {{Year,Month,Day},{Hour,Min,Sec}}}) ->
                                erl_syntax:tuple([
                                    erl_syntax:string(XFile),
                                    erl_syntax:tuple([
                                        erl_syntax:tuple([erl_syntax:integer(Year), erl_syntax:integer(Month), erl_syntax:integer(Day)]),
                                        erl_syntax:tuple([erl_syntax:integer(Hour), erl_syntax:integer(Min), erl_syntax:integer(Sec)])
                                    ])
                                ])
                            end, 
                            Dependencies1)) ])
            ]),     

	BodyLanguageAst = erl_syntax:match_expr(
							erl_syntax:variable("Language"),
							erl_syntax:application(
						        erl_syntax:atom(z_context), 
						        erl_syntax:atom(language),
						        [ z_context_ast(Context) ]
							)
					),

    BodyRenderAsts = case TreeWalker#treewalker.has_auto_id of
        false ->
            [BodyLanguageAst, BodyAst];
        true -> 
            AutoIdVar = resolve_scoped_variable_ast("$autoid", Context),
            BodyAutoIdAst = erl_syntax:match_expr(
                                    AutoIdVar,
                                    erl_syntax:application(
                                                erl_syntax:atom(z_ids),
                                                erl_syntax:atom(identifier),
                                                [erl_syntax:integer(8)]
                                    )
                             ),
            [BodyAutoIdAst, BodyLanguageAst, BodyAst]
    end,

    RenderInternalFunctionAst = erl_syntax:function(
        erl_syntax:atom(render2), 
            [ erl_syntax:clause(
					[erl_syntax:variable("Variables"), erl_syntax:variable("ZpContext")], 
					none, 
                	BodyRenderAsts)
			]),   
    
    ModuleAst = erl_syntax:attribute(erl_syntax:atom(module), [erl_syntax:atom(Module)]),
    
    ExportAst = erl_syntax:attribute(erl_syntax:atom(export),
        [erl_syntax:list([
		            erl_syntax:arity_qualifier(erl_syntax:atom(template_reset_counter), erl_syntax:integer(0)),
		            erl_syntax:arity_qualifier(erl_syntax:atom(trans_table), erl_syntax:integer(0)),
					erl_syntax:arity_qualifier(erl_syntax:atom(render), erl_syntax:integer(2)),
                    erl_syntax:arity_qualifier(erl_syntax:atom(source), erl_syntax:integer(0)),
                    erl_syntax:arity_qualifier(erl_syntax:atom(dependencies), erl_syntax:integer(0))])]),

    [erl_syntax:revert(X) || X <- [ModuleAst, ExportAst, TemplateResetCounterFunctionAst, TransTableFunctionAst,
            Render2FunctionAst, SourceFunctionAst, DependenciesFunctionAst, RenderInternalFunctionAst
            | BodyInfo#ast_info.pre_render_asts]].    


find_next([], _Find) -> error;
find_next([Find,Next|_], Find) -> {ok, Next};
find_next([_|Rest], Find) -> find_next(Rest, Find).


% child templates should only consist of blocks at the top level
body_extends(Extends, File, ThisParseTree, Context, TreeWalker) ->
    case lists:member(File, Context#dtl_context.parse_trail) of
        true ->
            throw({error, "Circular file inclusion: " ++ File});
        _ ->
            notify({debug, template, {extends, Extends, File}}, Context#dtl_context.z_context),
            case parse(File, Context) of
                {ok, ParentParseTree} ->
                    ThisFile = hd(Context#dtl_context.parse_trail),
                    BlockDict = lists:foldl(
                        fun
                            ({block, {identifier, _, Name}, Contents}, Dict) ->
                                Dict1 = dict:store(Name, {ThisFile, Contents}, Dict),
                                dict:store({Name, ThisFile}, Contents, Dict1);
                            (_, Dict) ->
                                Dict
                        end, dict:new(), ThisParseTree),
                    with_dependency(File, body_ast(ParentParseTree, Context#dtl_context{
                        block_dict = dict:merge(fun(_Key, _ParentVal, ChildVal) -> ChildVal end,
                                                BlockDict,
                                                Context#dtl_context.block_dict),
                        block_trail = [],
                        parse_trail = [File | Context#dtl_context.parse_trail],
                        extends_trail = [Extends | Context#dtl_context.extends_trail]}, TreeWalker));
                Err ->
                    throw(Err)
            end        
    end.

body_ast([overrules | ThisParseTree], Context, TreeWalker) ->
    CurrentExtend = hd(Context#dtl_context.extends_trail),
    CurrentFile = hd(Context#dtl_context.parse_trail),
    Files = full_path(CurrentExtend, true, Context),
    % Find the first file after the current file
    case find_next(Files, CurrentFile) of
        {ok, File} ->
            notify({debug, template, {overrules, CurrentExtend, File}}, Context#dtl_context.z_context),
            body_extends(CurrentExtend, File, ThisParseTree, Context, TreeWalker);
        error ->
            ?ERROR("body_ast: could not find overruled template for \"~p\" (~p)", [CurrentExtend,CurrentFile]),
            throw({error, "Could not find the template for overrules: '" ++ CurrentExtend ++ "'"}),
            {{erl_syntax:string(""), #ast_info{}}, TreeWalker}
    end;
    
body_ast([{extends, {string_literal, _Pos, String}} | ThisParseTree], Context, TreeWalker) ->
    Extends = unescape_string_literal(String),
    case full_path(Extends, Context) of
        {ok, File} ->
            body_extends(Extends, File, ThisParseTree, Context, TreeWalker);
       {error, Reason} ->
            ?ERROR("body_ast: could not find template ~p (~p)", [Extends, Reason]),
            throw({error, "Could not find the template for extends: '" ++ Extends ++ "'"}),
            {{erl_syntax:string(""), #ast_info{}}, TreeWalker}
    end;

body_ast(DjangoParseTree, Context, TreeWalker) ->
    {AstInfoList, TreeWalker2} = lists:mapfoldl(
        fun
            ({'block', {identifier, _, Name}, Contents}, TreeWalkerAcc) ->
                CurrentFile = case Context#dtl_context.block_trail of
                                    [] -> hd(Context#dtl_context.parse_trail);
                                    [{_, F}|_] -> F
                              end,
                % remember this block for an 'inherit' tag
                Context1 = Context#dtl_context{
                    block_dict=dict:store({Name,CurrentFile}, Contents, Context#dtl_context.block_dict)
                },
                % See if this block has been overruled
                {BlockFile, Block} = case dict:find(Name, Context#dtl_context.block_dict) of
                    {ok, {_ChildFile, _ChildBlock} = B} ->
                        B;
                    error ->
                        {CurrentFile, Contents}
                end,
                % Check if we have a recursive definition
                case lists:member({Name,BlockFile}, Context#dtl_context.block_trail) of
                    true ->
                        ?ERROR("body_ast: recursive block ~p (~p)", [Name, BlockFile]),
                        throw({error, "Recursive block definition of '" ++ Name ++ "' (" ++ BlockFile ++ ")"});
                    false ->
                        body_ast(Block,
                            Context1#dtl_context{block_trail=[{Name,BlockFile}|Context1#dtl_context.block_trail]}, 
                            TreeWalkerAcc)
                end;
            ('inherit', TreeWalkerAcc) ->
                inherit_ast(Context, TreeWalkerAcc);
            ({'comment', _Contents}, TreeWalkerAcc) ->
                empty_ast(TreeWalkerAcc);
			({'trans', {trans_text, _Pos, TransLiteral}}, TreeWalkerAcc) ->
				trans_ast(TransLiteral, Context, TreeWalkerAcc);
			({'trans_ext', {string_literal, _Pos, String}, Args}, TreeWalkerAcc) ->
				trans_ext_ast(String, Args, Context, TreeWalkerAcc);
            ({'date', 'now', {string_literal, _Pos, FormatString}}, TreeWalkerAcc) ->
                now_ast(FormatString, Context, TreeWalkerAcc);
            ({'autoescape', {identifier, _, OnOrOff}, Contents}, TreeWalkerAcc) ->
                body_ast(Contents, Context#dtl_context{auto_escape = list_to_atom(OnOrOff)}, 
                    TreeWalkerAcc);
            ({'text', _Pos, String}, TreeWalkerAcc) -> 
                string_ast(String, TreeWalkerAcc);
            ({'include', {string_literal, _, File}, Args, All}, TreeWalkerAcc) ->
                include_ast(unescape_string_literal(File), Args, All, Context, TreeWalkerAcc);
            ({'catinclude', {string_literal, _, File}, RscId, Args, All}, TreeWalkerAcc) ->
                catinclude_ast(unescape_string_literal(File), RscId, Args, All, Context, TreeWalkerAcc);
            ({'if', {'expr', "b_not", E}, Contents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = empty_ast(TreeWalkerAcc),
                {ElseAstInfo, TreeWalker2} = body_ast(Contents, Context, TreeWalker1),
                ifexpr_ast(E, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
            ({'if', E, Contents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
                {ElseAstInfo, TreeWalker2} = empty_ast(TreeWalker1),
                ifexpr_ast(E, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
            ({'ifelse', {'expr', "b_not", E}, IfContents, ElseContents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = body_ast(ElseContents, Context, TreeWalkerAcc),
                {ElseAstInfo, TreeWalker2} = body_ast(IfContents, Context, TreeWalker1),
                ifexpr_ast(E, IfAstInfo, ElseAstInfo, Context, TreeWalker2);                  
            ({'ifelse', E, IfContents, ElseContents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = body_ast(IfContents, Context, TreeWalkerAcc),
                {ElseAstInfo, TreeWalker2} = body_ast(ElseContents, Context, TreeWalker1),
                ifexpr_ast(E, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
            ({'ifequal', Args, Contents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = body_ast(Contents, Context, TreeWalkerAcc),
                {ElseAstInfo, TreeWalker2} = empty_ast(TreeWalker1),
                ifequalelse_ast(Args, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
            ({'ifequalelse', Args, IfContents, ElseContents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = body_ast(IfContents, Context, TreeWalkerAcc), 
                {ElseAstInfo, TreeWalker2} = body_ast(ElseContents, Context,TreeWalker1),
                ifequalelse_ast(Args, IfAstInfo, ElseAstInfo, Context, TreeWalker2);                
            ({'ifnotequal', Args, Contents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = empty_ast(TreeWalkerAcc),
                {ElseAstInfo, TreeWalker2} = body_ast(Contents, Context, TreeWalker1),
                ifequalelse_ast(Args, IfAstInfo, ElseAstInfo, Context, TreeWalker2);
            ({'ifnotequalelse', Args, IfContents, ElseContents}, TreeWalkerAcc) ->
                {IfAstInfo, TreeWalker1} = body_ast(ElseContents, Context, TreeWalkerAcc),
                {ElseAstInfo, TreeWalker2} = body_ast(IfContents, Context, TreeWalker1),
                ifequalelse_ast(Args, IfAstInfo, ElseAstInfo, Context, TreeWalker2);                    
            ({'with', [ExprList, Identifiers], WithContents}, TreeWalkerAcc) ->
                with_ast(ExprList, Identifiers, WithContents, Context, TreeWalkerAcc);
            ({'for', {'in', IteratorList, Value}, Contents}, TreeWalkerAcc) ->
                for_loop_ast(IteratorList, Value, Contents, none, Context, TreeWalkerAcc);
            ({'for', {'in', IteratorList, Value}, Contents, EmptyPartContents}, TreeWalkerAcc) ->
                for_loop_ast(IteratorList, Value, Contents, EmptyPartContents, Context, TreeWalkerAcc);
            ({'load', Names}, TreeWalkerAcc) ->
                load_ast(Names, Context, TreeWalkerAcc);
            ({'tag', {'identifier', _, Name}, Args, All}, TreeWalkerAcc) ->
                tag_ast(Name, Args, All, Context, TreeWalkerAcc);
            ({'call_args', {'identifier', _, Name}, Args}, TreeWalkerAcc) ->
            	call_ast(Name, Args, Context, TreeWalkerAcc);
            ({'call_with', {'identifier', _, Name}, With}, TreeWalkerAcc) ->
            	call_with_ast(Name, With, Context, TreeWalkerAcc);
            ({'cycle', Names}, TreeWalkerAcc) ->
                cycle_ast(Names, Context, TreeWalkerAcc);
            ({'cycle_compat', Names}, TreeWalkerAcc) ->
                cycle_compat_ast(Names, Context, TreeWalkerAcc);
            ({'media', Variable, Args}, TreeWalkerAcc) ->
                media_ast(Variable, Args, Context, TreeWalkerAcc);
            ({'image', Variable, Args}, TreeWalkerAcc) ->
                image_ast(Variable, Args, Context, TreeWalkerAcc);
            ({'image_url', Variable, Args}, TreeWalkerAcc) ->
                image_url_ast(Variable, Args, Context, TreeWalkerAcc);
            ({'url', {'identifier', _, Name}, Args}, TreeWalkerAcc) ->
                url_ast(Name, Args, Context, TreeWalkerAcc);
            ({'print', Value}, TreeWalkerAcc) ->
                print_ast(Value, Context, TreeWalkerAcc);
            ({'lib', LibList, Args}, TreeWalkerAcc) ->
                lib_ast(LibList, Args, Context, TreeWalkerAcc);
            ({'cache', [MaxAge, Args], CacheContents}, TreeWalkerAcc) ->
                cache_ast(MaxAge, Args, CacheContents, Context, TreeWalkerAcc);
            (ValueToken, TreeWalkerAcc) -> 
                {{ValueAst,ValueInfo},ValueTreeWalker} = value_ast(ValueToken, true, Context, TreeWalkerAcc),
                {{format(ValueAst, Context),ValueInfo},ValueTreeWalker}
        end, TreeWalker, DjangoParseTree),
    
    {AstList, {Info, TreeWalker3}} = lists:mapfoldl(
        fun({Ast, Info}, {InfoAcc, TreeWalkerAcc}) -> 
                PresetVars = lists:foldl(fun
                        (X, Acc) ->
                            case proplists:lookup(list_to_atom(X), Context#dtl_context.vars) of
                                none ->
                                    Acc;
                                Val ->
                                    [erl_syntax:abstract(Val) | Acc]
                            end
                    end, [], Info#ast_info.var_names),
                case PresetVars of
                    [] ->
                        {Ast, {merge_info(Info, InfoAcc), TreeWalkerAcc}};
                    _ ->
                        Counter = TreeWalkerAcc#treewalker.counter,
                        Name = lists:concat([pre_render, Counter]),
                        Ast1 = erl_syntax:application(none, erl_syntax:atom(Name),
                            [erl_syntax:list(PresetVars)]),
                        PreRenderAst = erl_syntax:function(erl_syntax:atom(Name),
                            [erl_syntax:clause([erl_syntax:variable("Variables")], none, [Ast])]),
                        PreRenderAsts = Info#ast_info.pre_render_asts,
                        Info1 = Info#ast_info{pre_render_asts = [PreRenderAst | PreRenderAsts]},     
                        {Ast1, {merge_info(Info1, InfoAcc), TreeWalkerAcc#treewalker{counter = Counter + 1}}}
                end
        end, {#ast_info{}, TreeWalker2}, AstInfoList),
    {{erl_syntax:list(AstList), Info}, TreeWalker3}.


merge_info(Info1, Info2) ->
    #ast_info{dependencies = 
        lists:merge(
            lists:sort(Info1#ast_info.dependencies), 
            lists:sort(Info2#ast_info.dependencies)),
        var_names = 
            lists:merge(
                lists:sort(Info1#ast_info.var_names), 
                lists:sort(Info2#ast_info.var_names)),
        pre_render_asts = 
            lists:merge(
                Info1#ast_info.pre_render_asts,
                Info2#ast_info.pre_render_asts)}.


%with_dependencies([], Args) ->
%    Args;
%with_dependencies([H, T], Args) ->
%     with_dependencies(T, with_dependency(H, Args)).
%        
with_dependency(FilePath, {{Ast, Info}, TreeWalker}) ->
    {{Ast, Info#ast_info{dependencies = [{FilePath, filelib:last_modified(FilePath)} | Info#ast_info.dependencies]}}, TreeWalker}.



inherit_ast(Context, TreeWalker) ->
    {BlockName,BlockFile} = hd(Context#dtl_context.block_trail),
    Inherited = [ {F, dict:find({BlockName,F}, Context#dtl_context.block_dict)} 
                || F <- find_prev_all(Context#dtl_context.parse_trail, BlockFile, []) ],
    case [ {F,C} || {F,{ok, C}} <- Inherited ] of
        [{InheritedFile,Content}|_] ->
            body_ast(Content,
                     Context#dtl_context{block_trail=[{BlockName,InheritedFile}|Context#dtl_context.block_trail]}, 
                     TreeWalker);
        [] ->
            {{erl_syntax:string(""), #ast_info{}}, TreeWalker}
    end.

    find_prev_all([], _Find, Acc) -> Acc;
    find_prev_all([Find|_], Find, Acc) -> Acc;
    find_prev_all([F|Rest], Find, Acc) -> find_prev_all(Rest, Find, [F|Acc]).


empty_ast(TreeWalker) ->
    {{erl_syntax:list([]), #ast_info{}}, TreeWalker}.


value_ast(ValueToken, AsString, Context, TreeWalker) ->
    case ValueToken of
        {'expr', Operator, Value} ->
            {{ValueAst,InfoValue}, TreeWalker1} = value_ast(Value, false, Context, TreeWalker),
            Ast = erl_syntax:application(erl_syntax:atom(erlydtl_operators), 
                                         erl_syntax:atom(Operator), 
                                         [ValueAst, z_context_ast(Context)]),
            {{Ast, InfoValue}, TreeWalker1};
        {'expr', Operator, Value1, Value2} ->
            {{Value1Ast,InfoValue1}, TreeWalker1} = value_ast(Value1, false, Context, TreeWalker),
            {{Value2Ast,InfoValue2}, TreeWalker2} = value_ast(Value2, false, Context, TreeWalker1),
            Ast = erl_syntax:application(erl_syntax:atom(erlydtl_operators), 
                                         erl_syntax:atom(Operator), 
                                         [Value1Ast, Value2Ast, z_context_ast(Context)]),
            {{Ast, merge_info(InfoValue1,InfoValue2)}, TreeWalker2};
        {'string_literal', _Pos, String} ->
            {{auto_escape(erl_syntax:string(unescape_string_literal(String)), Context), 
                    #ast_info{}}, TreeWalker};
		{'trans_literal', _Pos, String} ->
            {{auto_escape(trans_literal_ast(String, Context), Context), 
                    #ast_info{}}, TreeWalker};
        {'number_literal', _Pos, Number} ->
            case AsString of
                true  -> string_ast(Number, TreeWalker);
                false -> {{erl_syntax:integer(list_to_integer(Number)), #ast_info{}}, TreeWalker}
            end;
        {'atom_literal', _Pos, String} ->
            {{erl_syntax:atom(to_atom(unescape_string_literal(String))), #ast_info{}}, TreeWalker};
        undefined ->
            {{erl_syntax:atom(undefined), #ast_info{}}, TreeWalker};
        {'auto_id', Name} ->
            auto_id_ast(Name, Context, TreeWalker);
        {'apply_filter', Variable, Filter} ->
            filter_ast(Variable, Filter, Context, TreeWalker);
        {'attribute', _} = Variable ->
            {{Ast, VarName, VarInfo}, TreeWalker1} = resolve_variable_ast(Variable, Context, TreeWalker),
            {{Ast, merge_info(VarInfo,#ast_info{var_names = [VarName]})}, TreeWalker1};
        {'variable', _} = Variable ->
            {{Ast, VarName, VarInfo}, TreeWalker1} = resolve_variable_ast(Variable, Context, TreeWalker),
            {{Ast, merge_info(VarInfo, #ast_info{var_names = [VarName]})}, TreeWalker1};
        {'index_value', _, _} = Variable ->
            {{Ast, VarName, VarInfo}, TreeWalker1} = resolve_indexvariable_ast(Variable, Context, TreeWalker),
            {{Ast, merge_info(VarInfo, #ast_info{var_names = [VarName]})}, TreeWalker1};
        {tuple_value, {identifier, _, TupleName}, TupleArgs} ->
            TupleNameAst = erl_syntax:atom(TupleName),
            {TupleArgsAst, TreeWalker1} = scomp_ast_list_args(TupleArgs, Context, TreeWalker),
            {{erl_syntax:tuple([TupleNameAst, TupleArgsAst]), #ast_info{}}, TreeWalker1};
        {value_list, Values} ->
            {ValueAstList, ValueInfo, TreeWalker1} = lists:foldl(
                        fun(V, {Acc,Info,TreeW}) ->
                            {{Ast,InfoV}, TreeW1} = value_ast(V, false, Context, TreeW),
                            {[Ast|Acc], merge_info(Info,InfoV), TreeW1}
                        end,
                        {[], #ast_info{}, TreeWalker}, 
                        Values),
            {{erl_syntax:list(lists:reverse(ValueAstList)), ValueInfo},TreeWalker1}
    end.

string_ast(String, TreeWalker) ->
    % {{erl_syntax:string(String), #ast_info{}}, TreeWalker}. %% less verbose AST, better for development and debugging
    {{erl_syntax:binary([erl_syntax:binary_field(erl_syntax:integer(X)) || X <- String]), #ast_info{}}, TreeWalker}.       

catinclude_ast(File, Id, Args, All, Context, TreeWalker) ->
    Args1 = [ {{identifier, none, "$file"},{string_literal, none, File}},
			  {{identifier, none, "id"}, Id} | Args],
    scomp_ast("catinclude", Args1, All, Context, TreeWalker).


include_ast(File, Args, All, Context, TreeWalker) ->
    {UseScomp, IsSudo} = lists:foldl( fun({{identifier, _, Key}, Val}, {IsC,IsSu}) -> 
                                case Key of
                                    "maxage" -> {true, IsSu};
                                    "vary"   -> {true, IsSu};
                                    "scomp"  -> {true, IsSu};
                                    "visible_for" -> {true, IsSu};
                                    "sudo" ->
                                        case Val of
                                            true -> {IsC, true};
                                            _ -> {IsC, IsSu}
                                        end;
                                    _ -> {IsC, IsSu}
                                end
                            end,
                            {false, false},
                            Args),
    case UseScomp of
        false ->
            {InterpretedArgs, TreeWalker1} = interpreted_args(Args, Context, TreeWalker),
            {ScopedArgs, ArgAsts} = lists:foldr(
                fun({AKey, AAst}, {ScopeAcc, AstAcc}) ->
                    Var = "Arg_" ++ z_ids:identifier(10),
                    AssignAst = erl_syntax:match_expr(erl_syntax:variable(Var), AAst),
                    { [{AKey, erl_syntax:variable(Var)}|ScopeAcc], [AssignAst|AstAcc] }
                end,
                {[], []},
                InterpretedArgs),

            {ContextInclude,ArgAsts1} = case IsSudo of
                                true -> 
                                    V = "ZpContext_" ++ z_ids:id(10), 
                                    ZpContextAst = erl_syntax:match_expr(
                                                        erl_syntax:variable(V),
                                                        erl_syntax:application(
                                                                    erl_syntax:atom(z_acl),
                                                                    erl_syntax:atom(sudo),
                                                                    [z_context_ast(Context)])),
                                    LocalScope = [{'ZpContext', erl_syntax:variable(V)}],
                                    { Context#dtl_context{local_scopes=[LocalScope|Context#dtl_context.local_scopes]},
                                      [ZpContextAst|ArgAsts] 
                                    };
                                false -> 
                                    {Context, ArgAsts}
                             end,

            % {AstList, Info, TreeWalker}
            IncludeFun = fun(FilePath, {AstList, InclInfo, TreeW}) ->
                    notify({debug, template, {include, File, FilePath}}, ContextInclude#dtl_context.z_context),
                    case parse(FilePath, ContextInclude) of
                        {ok, InclusionParseTree} ->
                            AutoIdVar = "AutoId_"++z_ids:identifier(),
                            IncludeScope = [ {'$autoid', erl_syntax:variable(AutoIdVar)} | ScopedArgs ],

                            {{Ast,Info}, InclTW2} = 
                                            with_dependency(FilePath, 
                                                    body_ast(
                                                        InclusionParseTree,
                                                        Context#dtl_context{
                                                                local_scopes = [ IncludeScope | ContextInclude#dtl_context.local_scopes ],
                                                                parse_trail = [FilePath | ContextInclude#dtl_context.parse_trail]}, 
                                                        TreeW#treewalker{has_auto_id=false})),
                            Ast1 = case InclTW2#treewalker.has_auto_id of
                                false -> Ast;
                                true ->  erl_syntax:block_expr(
                                            [
                                            erl_syntax:match_expr(
                                                    erl_syntax:variable(AutoIdVar), 
                                                    erl_syntax:application(
                                                        erl_syntax:atom(z_ids),
                                                        erl_syntax:atom(identifier),
                                                        [])),
                                            Ast])
                            end,
                            {[Ast1|AstList], merge_info(InclInfo, Info), InclTW2#treewalker{has_auto_id=TreeW#treewalker.has_auto_id}};
                        Err ->
                            throw(Err)
                    end
            end,

            % Compile all included files, put them in a block expr with a single assignment of the argument vars at the start.
            case lists:foldl(IncludeFun, {[], #ast_info{}, TreeWalker1}, full_path(File, All, Context)) of
                {[], _, TreeWalkerN} ->
                    case All of
                        false -> ?LOG("include_ast: could not find template ~p", [File]);
                        true -> ok
                    end,
                    {{erl_syntax:string(""), #ast_info{}}, TreeWalkerN};
                {AstList, AstInfo, TreeWalkerN} ->
                    AstN = erl_syntax:block_expr(ArgAsts1 ++ [erl_syntax:list(lists:reverse(AstList))]),
                    {{AstN, AstInfo}, TreeWalkerN}
            end;
        true ->
            Args1 = [{{identifier, none, "$file"},{string_literal, none, File}} | Args],
            scomp_ast("include", Args1, All, Context, TreeWalker)
    end.


filter_ast(Variable, Filter, Context, TreeWalker) ->
    % the escape filter is special; it is always applied last, so we have to go digging for it

    % AutoEscape = 'did' means we (will have) decided whether to escape the current variable,
    % so don't do any more escaping
    {{UnescapedAst, Info}, TreeWalker2} = filter_ast_noescape(Variable, Filter, Context#dtl_context{auto_escape = did}, TreeWalker),
    case search_for_escape_filter(Variable, Filter, Context) of
        on ->
            {{erl_syntax:application(
                    erl_syntax:atom(filter_force_escape), 
                    erl_syntax:atom(force_escape), 
                    [UnescapedAst, z_context_ast(Context)]), 
                Info}, TreeWalker2};
        _ ->
            {{UnescapedAst, Info}, TreeWalker2}
    end.

filter_ast_noescape(Variable, {filter, {identifier, _, "escape"}, []}, Context, TreeWalker) ->
    value_ast(Variable, true, Context, TreeWalker);
filter_ast_noescape(Variable, Filter, Context, TreeWalker) ->
    {{VariableAst,Info},TreeWalker2} = value_ast(Variable, true, Context, TreeWalker),
    {{FilterAst,Info2},TreeWalker3} = filter_ast1(Filter, VariableAst, Context, TreeWalker2),
    {{FilterAst, merge_info(Info, Info2)}, TreeWalker3}.

filter_ast1({filter, {identifier, _, Name}, []}, VariableAst, Context, TreeWalker) ->
    FilterAst = erl_syntax:application(erl_syntax:atom(list_to_atom("filter_"++Name)), erl_syntax:atom(Name), [VariableAst, z_context_ast(Context)]),
    {{FilterAst, #ast_info{}}, TreeWalker};
filter_ast1({filter, {identifier, _, "default"}, [Arg]}, VariableAst, Context, TreeWalker) ->
    {{ArgAst, Info},TreeWalker1} = value_ast(Arg, false, Context, TreeWalker),
    VarAst  = erl_syntax:variable("Default_" ++ z_ids:identifier()),
    CaseAst = erl_syntax:case_expr(erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(is_false), [VarAst]),
        [erl_syntax:clause([erl_syntax:atom(true)], none, 
                [ArgAst]),
         erl_syntax:clause([erl_syntax:underscore()], none,
                [VarAst])
        ]),
    {{erl_syntax:block_expr([erl_syntax:match_expr(VarAst, VariableAst), CaseAst]), Info}, TreeWalker1};
filter_ast1({filter, {identifier, _, "default_if_none"}, [Arg]}, VariableAst, Context, TreeWalker) ->
    {{ArgAst, Info},TreeWalker1} = value_ast(Arg, false, Context, TreeWalker),
    VarAst  = erl_syntax:variable("Default_" ++ z_ids:identifier()),
    CaseAst = erl_syntax:case_expr(VariableAst,
        [erl_syntax:clause([erl_syntax:atom(undefined)], none, 
                [ArgAst]),
         erl_syntax:clause([VarAst], none,
                [VarAst])
        ]),
    {{CaseAst, Info}, TreeWalker1};
filter_ast1({filter, {identifier, Pos, "default_if_undefined"}, Args}, VariableAst, Context, TreeWalker) ->
    filter_ast1({filter, {identifier, Pos, "default_if_none"}, Args}, VariableAst, Context, TreeWalker);
filter_ast1({filter, {identifier, _, Name}, Args}, VariableAst, Context, TreeWalker) ->
    {{ArgAsts, Info}, TreeWalker2} = lists:foldr(
                        fun(Arg, {{As,In},Tw}) ->
                            {{ArgAst,ArgIn}, Tw1} = value_ast(Arg, false, Context, Tw),
                            {{[ArgAst|As], merge_info(In,ArgIn)}, Tw1}
                        end,
                        {{[], #ast_info{}}, TreeWalker},
                        Args),
    FilterAst = erl_syntax:application(
                    erl_syntax:atom(list_to_atom("filter_"++Name)), 
                    erl_syntax:atom(Name), 
                    [VariableAst|ArgAsts] ++ [z_context_ast(Context)]
                ),
    {{FilterAst, Info}, TreeWalker2}.
    
 
search_for_escape_filter(_, _, #dtl_context{auto_escape = on}) ->
    on;
search_for_escape_filter(_, _, #dtl_context{auto_escape = did}) ->
    off;
search_for_escape_filter(Variable, Filter, _) ->
    search_for_escape_filter(Variable, Filter).

search_for_escape_filter(_, {filter, {identifier, _, "escape"}, []}) ->
    on;
search_for_escape_filter({apply_filter, Variable, Filter}, _) ->
    search_for_escape_filter(Variable, Filter);
search_for_escape_filter(_Variable, _Filter) ->
    off.



resolve_variable_ast(VarTuple, Context, TreeWalker) ->
    opttrans_variable_ast(resolve_variable_ast(VarTuple, Context, TreeWalker, 'fetch_value'), Context).

resolve_ifvariable_ast(VarTuple, Context, TreeWalker) ->
    opttrans_variable_ast(resolve_variable_ast(VarTuple, Context, TreeWalker, 'find_value'), Context).

resolve_indexvariable_ast(VarTuple, Context, TreeWalker) ->
    opttrans_variable_ast(resolve_variable_ast(VarTuple, Context, TreeWalker, 'fetch_value'), Context).


opttrans_variable_ast({{Ast, VarName, Info}, TreeWalker}, Context) ->
    Ast1 = erl_syntax:application(
            erl_syntax:atom(z_trans), 
            erl_syntax:atom(lookup_fallback),
			[
				Ast,
				z_context_ast(Context)
			]),
	{{Ast1, VarName, Info}, TreeWalker}.

resolve_variable_ast({index_value, Variable, Index}, Context, TreeWalker, FinderFunction) ->
    {{IndexAst,Info},TreeWalker2} = value_ast(Index, false, Context, TreeWalker),
    {{VarAst, VarName, Info2}, TreeWalker3} = resolve_variable_ast(Variable, Context, TreeWalker2, FinderFunction),
    Ast = erl_syntax:application(
            erl_syntax:atom(erlydtl_runtime), 
            erl_syntax:atom(FinderFunction),
            [IndexAst, VarAst, z_context_ast(Context)]),
    {{Ast, VarName, merge_info(Info, Info2)}, TreeWalker3};

resolve_variable_ast({attribute, {{identifier, _, Arg}, {variable, {identifier, _, "q"}}}}, Context, TreeWalker, _FinderFunction) ->
    Ast = erl_syntax:application(
            erl_syntax:atom(z_context), 
            erl_syntax:atom(get_q),
            [erl_syntax:string(Arg), z_context_ast(Context)]),
    {{Ast, "q", #ast_info{}}, TreeWalker};

resolve_variable_ast({attribute, {{identifier, _, Arg}, {variable, {identifier, _, "q_validated"}}}}, Context, TreeWalker, _FinderFunction) ->
    Ast = erl_syntax:application(
            erl_syntax:atom(z_context), 
            erl_syntax:atom(get_q_validated),
            [erl_syntax:string(Arg), z_context_ast(Context)]),
    {{Ast, "q", #ast_info{}}, TreeWalker};

resolve_variable_ast({attribute, {{identifier, _, Model}, {variable, {identifier, _, "m"}}}}, _Context, TreeWalker, _FinderFunction) ->
    Ast = erl_syntax:tuple([
            erl_syntax:atom(m),
            erl_syntax:atom("m_" ++ Model),
            erl_syntax:atom(undefined)
        ]),
    {{Ast, "m", #ast_info{}}, TreeWalker};

resolve_variable_ast({attribute, {{identifier, _, AttrName}, Variable}}, Context, TreeWalker, FinderFunction) ->
    {{VarAst, VarName, Info}, TreeWalker2} = resolve_variable_ast(Variable, Context, TreeWalker, FinderFunction),
    Ast = erl_syntax:application(
            erl_syntax:atom(erlydtl_runtime),
            erl_syntax:atom(FinderFunction),
            [erl_syntax:atom(AttrName), VarAst, z_context_ast(Context)]),
    {{Ast, VarName, Info}, TreeWalker2};

resolve_variable_ast({variable, {identifier, _, "now"}}, Context, TreeWalker, _FinderFunction) ->
    Ast = case resolve_scoped_variable_ast("now", Context) of
        undefined ->
            erl_syntax:application(
                erl_syntax:atom(erlang),
                erl_syntax:atom(localtime),
                []);
        Val ->
            Val
    end,
    {{Ast, "now", #ast_info{}}, TreeWalker};

resolve_variable_ast({variable, {identifier, _, "z_language"}}, Context, TreeWalker, _FinderFunction) ->
    Ast = case resolve_scoped_variable_ast("z_language", Context) of
        undefined ->
            erl_syntax:application(
                erl_syntax:atom(z_context),
                erl_syntax:atom(language),
                [z_context_ast(Context)]);
        Val ->
            Val
    end,
    {{Ast, "z_language", #ast_info{}}, TreeWalker};


resolve_variable_ast({variable, {identifier, _, VarName}}, Context, TreeWalker, FinderFunction) ->
    Ast = case resolve_scoped_variable_ast(VarName, Context) of
        undefined ->
            erl_syntax:application(
                erl_syntax:atom(erlydtl_runtime), 
                erl_syntax:atom(FinderFunction),
                [erl_syntax:atom(VarName), erl_syntax:variable("Variables"), z_context_ast(Context)]);
        Val ->
            Val
    end,
    {{Ast, VarName, #ast_info{}}, TreeWalker};

resolve_variable_ast({apply_filter, Variable, Filter}, Context, TreeWalker, FinderFunction) ->
    {{VarAst, VarName, Info}, TreeWalker2} = resolve_variable_ast(Variable, Context, TreeWalker, FinderFunction),
    ValueAst = erl_syntax:application(
            erl_syntax:atom(erlydtl_runtime),
            erl_syntax:atom(to_value),
            [VarAst, z_context_ast(Context)]
        ),
    {{VarValue, Info2}, TreeWalker3} = filter_ast1(Filter, ValueAst, Context, TreeWalker2),
    {{VarValue, VarName, merge_info(Info, Info2)}, TreeWalker3};

resolve_variable_ast(ValueToken, Context, TreeWalker, _FinderFunction) ->
    {{Ast, Info}, TreeWalker1} = value_ast(ValueToken, false, Context, TreeWalker),
    {{Ast, "$value", Info}, TreeWalker1}.


resolve_scoped_variable_ast(VarName, Context) ->
    lists:foldl(fun(Scope, Value) ->
                case Value of
                    undefined -> proplists:get_value(list_to_atom(VarName), Scope);
                    _ -> Value
                end
        end, undefined, Context#dtl_context.local_scopes).


%% @doc Return the AST for the z_context var
z_context_ast(Context) ->
    case resolve_scoped_variable_ast("ZpContext", Context) of
        undefined -> erl_syntax:variable("ZpContext"); 
        Ast -> Ast
    end.


format(Ast, Context) ->
    auto_escape(stringify(Ast, Context), Context).

stringify(Ast, Context) ->
    erl_syntax:application(erl_syntax:atom(filter_stringify), erl_syntax:atom(stringify),
        [Ast, z_context_ast(Context)]).

auto_escape(Value, Context) ->
    case Context#dtl_context.auto_escape of
        on ->
            erl_syntax:application(erl_syntax:atom(filter_force_escape), erl_syntax:atom(force_escape),
                [Value, z_context_ast(Context)]);
        _ ->
            Value
    end.

ifexpr_ast(Expression, {IfContentsAst, IfContentsInfo}, {ElseContentsAst, ElseContentsInfo}, Context, TreeWalker) ->
    Info = merge_info(IfContentsInfo, ElseContentsInfo),
    {{Ast, ExpressionInfo}, TreeWalker1} = value_ast(Expression, false, Context, TreeWalker),
    {{erl_syntax:case_expr(erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(is_false), [Ast]),
        [erl_syntax:clause([erl_syntax:atom(true)], none, 
                [ElseContentsAst]),
        erl_syntax:clause([erl_syntax:underscore()], none,
                [IfContentsAst])
        ]), merge_info(ExpressionInfo, Info)}, TreeWalker1}.
    

ifequalelse_ast(Args, {IfContentsAst, IfContentsInfo}, {ElseContentsAst, ElseContentsInfo}, Context, TreeWalker) ->
    Info = merge_info(IfContentsInfo, ElseContentsInfo),
    {[Arg1Ast, Arg2Ast], VarNames, Info1, TreeWalker1} = lists:foldl(fun
            (X, {Asts, AccVarNames, Inf, TW}) ->
                case X of
					{string_literal, _, Literal} ->
					    {[erl_syntax:string(unescape_string_literal(Literal)) | Asts], AccVarNames, Inf, TW};
				    {trans_literal, _, Literal} ->
				        {[trans_literal_ast(Literal, Context) | Asts], AccVarNames, Inf, TW};
                    {number_literal, _, Literal} ->
                        {[erl_syntax:integer(list_to_integer(Literal)) | Asts], AccVarNames, Inf, TW};
                    Variable ->
                        {{Ast, VarName, VarInfo}, TW1} = resolve_ifvariable_ast(Variable, Context, TW),
                        {[Ast | Asts], [VarName | AccVarNames], merge_info(Inf, VarInfo), TW1}
                end                
        end,
        {[], Info#ast_info.var_names, #ast_info{}, TreeWalker},
        Args),
    Ast = erl_syntax:case_expr(erl_syntax:application(erl_syntax:atom(erlydtl_runtime), erl_syntax:atom(are_equal),
            [Arg1Ast, Arg2Ast]),
        [
            erl_syntax:clause([erl_syntax:atom(true)], none, [IfContentsAst]),
            erl_syntax:clause([erl_syntax:underscore()], none, [ElseContentsAst])
        ]),
    {{Ast, merge_info(Info1, Info#ast_info{var_names = VarNames})}, TreeWalker1}.         


%% With statement with only a single variable, easy & quick match.
with_ast([Value], [{identifier, _, V}], Contents, Context, TreeWalker) ->
    Postfix = z_ids:identifier(),
    VarAst  = erl_syntax:variable("With_" ++ V ++ [$_|Postfix]),
    {{ValueAst, ValueInfo}, TreeWalker1} = value_ast(Value, false, Context, TreeWalker),
    LocalScope = [ {list_to_atom(V), VarAst} ],
    {{InnerAst, InnerInfo}, TreeWalker2} = body_ast(
            Contents,
            Context#dtl_context{local_scopes=[LocalScope | Context#dtl_context.local_scopes]}, 
            TreeWalker1),
    WithAst = erl_syntax:block_expr([erl_syntax:match_expr(VarAst, ValueAst), InnerAst]),
    {{WithAst, merge_info(ValueInfo,InnerInfo)}, TreeWalker2};
    
%% With statement with multiple vars, match against tuples and lists.
with_ast([Value], Variables, Contents, Context, TreeWalker) ->
    Postfix = z_ids:identifier(),
    VarAsts = lists:map(fun({identifier, _, V}) -> 
                    erl_syntax:variable("With_" ++ V ++ [$_|Postfix]) 
            en…