}
        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,
    /**

            visitor.visitQuoted(expression);
        } else if (expression.getType() == IncludeType.IDENTIFIER) {
            visitor.visitIdentifier(expression);
        } else if (expression.getType() == IncludeType.ARGS_LIST) {
            visitor.visitTokens(expression);
        } else {
            if (!visitor.startVisit(expression)) {
                // Skip, visitor is not interested
                return;
            }

        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)))

        }
        def e = RegexBackedCSourceParser.parseExpression("m($value)")
        assert e.arguments.size() == 1 && (e.arguments[0].type == IncludeType.EXPRESSIONS || e.arguments[0].type == IncludeType.ARGS_LIST || e.arguments[0].type == IncludeType.TOKEN_CONCATENATION)
        return e.arguments[0]
    }

    Include include(String value, boolean isImport = false) {

            return;
        }
        Expression expression = parseDirectiveBodyExpression(buffer);
        if (expression.getType() == IncludeType.TOKEN_CONCATENATION || expression.getType() == IncludeType.ARGS_LIST || expression.getType() == IncludeType.EXPRESSIONS) {
            // Token concatenation is only allowed inside a #define body
            // Arbitrary tokens won't resolve to an include path