Annotation Processor in IntelliJ and Gradle

tl;dr: I cannot configure IntelliJ to generate the java files in the same directory as gradle

I have a small project which uses the immutables annotation processor. It works as expected in the gradle command line build, but I cannot get IntelliJ to output the generated files to the same directory.

The full project is available on GitLab

Gradle config:
I use the folowing gradle plugins:

gradle-idea plugin which handles the idea configuration
gradle-apt-plugin which provides the apt configuration and handles the compile-class path and idea config related to annotation processing (if also the idea plugin is applied)

relevant parts of the build-script (link to the full listing):

apply plugin: 'java'
apply plugin: "net.ltgt.apt"
apply plugin: 'idea'

dependencies {
    def immutablesVersion = '2.3.9'
    compileOnly "org.immutables:value:$immutablesVersion:annotations"
    compileOnly "org.immutables:encode:$immutablesVersion"
    apt "org.immutables:value:$immutablesVersion"
}

when I start ./gradlew build everything is as expected:

The source file DataEncoding.java is processed an the generated java-file DataEncodingEnabled.java ends up in
/build/generated/source/apt/main under the expected package com.tmtron.immutables.data
and the generated file is also compiled to a .class file

In IntelliJ I activate the annotation processing as suggested by the gradle-apt-plugin docs:

Then I execute ./gradlew clean to make sure, that the previous files are gone and then I click Build - Build Project in IntelliJ.
The annotation processor is executed, but the problem is that the generated java file ends up in the wrong location:

It is in: /build/generated/source/apt/main/build/generated/source/apt/main/com.tmtron.immutables.data
the bold part is redundant.

What am I doing wrong and how can I set it up correctly, so that IntelliJ and gradle generate the files in the same directory?

Notes:

I have of course already tried to just leave the "Production sources dir" in the IntelliJ annotation configuration empty, but his does not work: then it automatically uses "generated" and I also end up with a wrong path.
IntelliJ version 2016.3.4

UPDATE 2.2019
since Gradle 5.2 there is an easy way to do it - see gavenkoas answer

UPDATE 5.2018

The easiest way, I know of is to use the apt-idea plugin

Just activate the plugin in the build.gradle file:

plugins {
    id 'java'
    id 'net.ltgt.apt-idea' version "0.15"
}

and then add the annotation processors to the annotationProcessor configuration:

final DAGGER_VER = '2.16'
dependencies {
    implementation "com.google.dagger:dagger:${DAGGER_VER}"
    annotationProcessor"com.google.dagger:dagger-compiler:${DAGGER_VER}"
}

Test-project on GitHub: ex.dagger
(using IntelliJ 2018.1.4, Gradle 4.7)

ORIG ANSWER

There's a simple workaround using the parent-dir which works fine in IntelliJ 2016.3.4

Production sources directory: ../main
Test sources directory: ../test

Now gradle and IntelliJ will generate the code to the same directories.

Fixed in GitLab project V0.0.2

see also: apt-gradle-plugin issue#35

Now https://github.com/tbroyer/gradle-apt-plugin states:

The goal of this plugin was to eventually no longer be needed, being superseded by built-in features. This is becoming a reality with Gradle 5.2 and IntelliJ IDEA 2019.1.

So:

dependencies {
  compile("com.google.dagger:dagger:2.18")
  annotationProcessor("com.google.dagger:dagger-compiler:2.18")

  compileOnly("com.google.auto.factory:auto-factory:1.0-beta6")
  annotationProcessor("com.google.auto.factory:auto-factory:1.0-beta6")

  compileOnly("org.immutables:value-annotations:2.7.1")
  annotationProcessor("org.immutables:value:2.7.1")
}

compileOnly is necessary if you use annotations, compile if you use classes, annotationProcessor introduced in Gradle 4.6.

To enable processing specific compile task:

compileJava {
    options.annotationProcessorPath = configurations.annotationProcessor
}

To disable:

  compileTestJava {
      options.compilerArgs += '-proc:none'
  }

Hey there everyone I had the same issue and found a clean way of solving this issue. I am using two libraries that require annotation processing (Lombok and MapStruct).

Also my IntelliJ is 2019.1 (update yours in case it's older) and Gradle 5.2.1.

First let's configure IntelliJ: