}
        if (expression.getType() == IncludeType.ARGS_LIST && !expression.getArguments().isEmpty()) {
            List<Expression> mapped = new ArrayList<Expression>(expression.getArguments().size());
            for (Expression arg : expression.getArguments()) {
                mapped.add(arg.asMacroExpansion());
            }
            return new ComplexExpression(IncludeType.ARGS_LIST, null, mapped);
        }
        return expression;

     * Returns the left and right arguments of the expression when type is {@link IncludeType#TOKEN_CONCATENATION}.
     * Returns the sequence of arguments when type is {@link IncludeType#ARGS_LIST}.
     * Returns the sequence of expressions when type is {@link IncludeType#EXPRESSIONS}.
     */
    List<Expression> getArguments();

    /**
     * Returns this expression as a macro expansion expression.

    public static final Expression EMPTY_EXPRESSIONS = new SimpleExpression(null, IncludeType.EXPRESSIONS);
    static final Expression EMPTY_ARGS = new SimpleExpression(null, IncludeType.ARGS_LIST);
    static final Expression LEFT_PAREN = new SimpleExpression("(", IncludeType.TOKEN);
    static final Expression COMMA = new SimpleExpression(",", IncludeType.TOKEN);

     */
    IDENTIFIER,
    /**
     * A macro function argument list. These appear in the body of a directive or as the arguments to a {@link #MACRO_FUNCTION} eg {@code #include ABC(a b c)}.
     */
    ARGS_LIST,
    /**
     * A sequence of expressions. These appear as the arguments to a {@link #MACRO_FUNCTION} eg {@code #include ABC(a b c)}.
     */
    EXPRESSIONS,
    /**

        def include = new IncludeWithMacroFunctionCallExpression("A", true, ImmutableList.of(
            new SimpleExpression(null, IncludeType.EXPRESSIONS),
            new SimpleExpression(null, IncludeType.ARGS_LIST),
            new SimpleExpression(",", IncludeType.TOKEN),
            new SimpleExpression("(", IncludeType.TOKEN),
            new SimpleExpression(")", IncludeType.TOKEN)))