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;

    public ComplexExpression(IncludeType type, @Nullable String value, List<Expression> arguments) {
        this.type = type;
        this.value = value;

            return new SimpleExpression(expression.getValue(), IncludeType.MACRO);
        }
        if (expression.getType() == IncludeType.TOKEN_CONCATENATION) {
            return new ComplexExpression(IncludeType.EXPAND_TOKEN_CONCATENATION, expression.getValue(), expression.getArguments());
        }
        if (expression.getType() == IncludeType.ARGS_LIST && !expression.getArguments().isEmpty()) {

    def "serializes nested expression"() {
        def expression1 = new ComplexExpression(IncludeType.MACRO_FUNCTION, "X", [new SimpleExpression("Y", IncludeType.MACRO)])
        def expression2 = new ComplexExpression(IncludeType.MACRO_FUNCTION, "X", [new SimpleExpression("Y", IncludeType.MACRO), new SimpleExpression("Z", IncludeType.MACRO)])

        int currentMapPos = 0;
        for (Expression argument : this.arguments) {
            currentMapPos = mapInto(argument, arguments, currentMapPos, mapped);
        }
        return new ComplexExpression(type, value, mapped);
    }

    private int mapInto(Expression expression, List<Expression> arguments, int currentMapPos, List<Expression> mapped) {
        int replaceWith = argsMap[currentMapPos];

        String right = buffer.readIdentifier();
        if (right == null) {
            // Need another identifier
            buffer.pos = pos;
            return null;
        }
        ComplexExpression concatExpression = new ComplexExpression(IncludeType.TOKEN_CONCATENATION, null, Arrays.<Expression>asList(new SimpleExpression(leftToken, IncludeType.IDENTIFIER), new SimpleExpression(right, IncludeType.IDENTIFIER)));

                return new ComplexExpression(type, expressionValue, args);
            } else if (tag == COMPLEX_MULTIPLE_ARGS) {
                String expressionValue = decoder.readNullableString();
                IncludeType type = enumSerializer.read(decoder);
                List<Expression> args = ImmutableList.copyOf(argsSerializer.read(decoder));
                return new ComplexExpression(type, expressionValue, args);

            if (value.getType() != IncludeType.IDENTIFIER) {
                visitor.visitUnresolved();
                continue;
            }
            ComplexExpression macroExpression = new ComplexExpression(IncludeType.MACRO_FUNCTION, value.getValue(), args.getArguments());
            if (headExpressions.isEmpty()) {
                resolveExpression(visibleMacros, macroExpression, visitor, tokenLookup);

Class <org.gradle.language.nativeplatform.internal.incremental.sourceparser.ComplexExpression> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (ComplexExpression.java:0)