public static final IncludeDirectivesSerializer INSTANCE = new IncludeDirectivesSerializer();

    private final Serializer<IncludeType> enumSerializer = new BaseSerializerFactory().getSerializerFor(IncludeType.class);
    private final Serializer<Expression> expressionSerializer = new ExpressionSerializer(enumSerializer);

        if (expression.getType() == IncludeType.SYSTEM) {
            visitor.visitSystem(expression);
        } else if (expression.getType() == IncludeType.QUOTED) {
            visitor.visitQuoted(expression);
        } else if (expression.getType() == IncludeType.IDENTIFIER) {
            visitor.visitIdentifier(expression);
        } else if (expression.getType() == IncludeType.ARGS_LIST) {
            visitor.visitTokens(expression);

    private final boolean isImport;
    private final IncludeType type;

    public static IncludeWithSimpleExpression create(String value, boolean isImport, IncludeType type) {
        return INTERNER.intern(new IncludeWithSimpleExpression(value, isImport, type));
    }

    public static Include create(Expression expression, boolean isImport) {
        if (expression.getType() == IncludeType.MACRO_FUNCTION && !expression.getArguments().isEmpty()) {

    }

    Expression tokens(String value) {
        if (value.empty) {
            return new SimpleExpression(null, IncludeType.EXPRESSIONS)
        }
        def e = RegexBackedCSourceParser.parseExpression("m($value)")

import org.gradle.language.nativeplatform.internal.IncludeType;

import java.util.List;

/**
 * A macro function whose body cannot be resolved.
 */
public class UnresolvableMacroFunction extends AbstractMacroFunction {
    private static final SimpleExpression UNRESOLVED_EXPRESSION = new SimpleExpression(null, IncludeType.OTHER);

    public UnresolvableMacroFunction(String name, int parameters) {

import org.gradle.language.nativeplatform.internal.IncludeType;

import javax.annotation.Nullable;
import java.util.List;

/**
 * An expression with arguments.
 */
public class ComplexExpression extends AbstractExpression {
    private final IncludeType type;
    private final String value;
    private final List<Expression> arguments;

import org.gradle.language.nativeplatform.internal.IncludeType;

import javax.annotation.Nullable;
import java.util.List;

/**
 * An "object-like" macro #define whose body is an expression with arguments.
 */
public class MacroWithComplexExpression extends AbstractMacro {
    private final IncludeType type;
    private final String value;
    private final List<Expression> arguments;

import org.gradle.language.nativeplatform.internal.IncludeType;

import javax.annotation.Nullable;
import java.util.List;

/**
 * A macro function that returns a fixed expression and ignores its parameters.
 */
public class ReturnFixedValueMacroFunction extends AbstractMacroFunction implements Expression {
    private final String value;
    private final IncludeType type;
    private final List<Expression> arguments;

                return element.getType() == IncludeType.QUOTED;
            }
        });
    }

    @Override
    public List<Include> getSystemIncludes() {
        return CollectionUtils.filter(allIncludes, new Spec<Include>() {
            @Override
            public boolean isSatisfiedBy(Include element) {
                return element.getType() == IncludeType.SYSTEM;
            }
        });
    }

import org.gradle.language.nativeplatform.internal.IncludeType


class TestIncludeParser {
    static IncludeDirectives systemIncludes(Collection<String> names) {
        return DefaultIncludeDirectives.of(ImmutableList.copyOf(names.collect { new IncludeWithSimpleExpression(it, false, IncludeType.SYSTEM) }), ImmutableList.of(), ImmutableList.of())
    }