CODEWITHSUNDEEP
gradlegenerated
user447607
user447607

Reputation: 5469

How do I get IntelliJ to recognize gradle generated sources dir?

So I have an XJC javaExec that spins like a top but IntelliJ doesn't recognize the generated output despite having marked generated-src/java as such. Do I need to tweak the idea plug-in or something?

Note: The plug-in itself is loaded in subProjects from the root build.gradle.

XJC Project:

description = "Generates sources and compiles them into a Jar for $project"

configurations { xjc }
dependencies {
    xjc 'org.glassfish.jaxb:jaxb-xjc:2.2.11'
    xjc 'org.glassfish.jaxb:jaxb-runtime:2.2.11'
}

task xjc (type:JavaExec) {

    doFirst{
        File generatedSrcDir = file("$buildDir/generated-src/java")
        if (!generatedSrcDir.exists()) {
            generatedSrcDir.mkdirs()
        }
    }

    main = "com.sun.tools.xjc.XJCFacade"
    classpath configurations.xjc

    def argsList = [
            "-mark-generated",
            "-no-header",
            "-verbose", // or -quiet or nothing for default.
            "-target", "2.1",
            "-encoding", "UTF-8",
            "-d", "$buildDir/generated-src/java",
            "-catalog","$projectDir/src/main/resources/commons-gradle.cat",
            file("$projectDir/src/main/resources/v1/") ]

    args argsList
    inputs.files files(file("$projectDir/src/main/resources/v1/"))
    outputs.files files(file("$buildDir/generated-src/java"),file("$buildDir/classes"))

}

compileJava {
    dependsOn xjc
    source "${buildDir}/generated-src"
}

In the project that depends on this one I simply have:

compile project(":path:to:schemas:the-test-schema")

I've tried:

idea {
    module {

        def buildDir = file("$buildDir")
        def generatedDir = file("$buildDir/generated-src")
        def listOfDirs = []

        buildDir.eachDir { file ->
            if (file.name != buildDir.name && file.name != generatedDir.name)
            listOfDirs.add(file)
        }

        excludeDirs = listOfDirs.toArray()

        generatedSourceDirs += file("$buildDir/generated-src/java")
        scopes.COMPILE.plus += [ configurations.xjc ]
    }
}

Upvotes: 17

Views: 16337

Answers (6)

rios0rios0
rios0rios0

Reputation: 925

It's happening in some versions. There are some issues that we can look at and read carefully. But for myself, from the IntelliJ IDEA 2019 the solutions below aren't working anymore:

Discussion in the Gradle forum about this: https://discuss.gradle.org/t/how-do-i-get-intellij-to-recognize-gradle-generated-sources-dir/16847

According to @Daniel Dekany, this worked in IDEA 2017.1.2, and worked for me until 2019:

plugins {
    id 'idea'
}

idea {
    module {
        generatedSourceDirs += file('build/generated/sources/annotationProcessor')
    }
}

But from 2019 to 2022, the solution that worked for me was:

def generatedDir = "${buildDir}/generated/sources"

sourceSets {
    main {
        java {
            srcDir generatedDir
        }
    }
}

idea {
    module {
        generatedSourceDirs.addAll(file(generatedDir))
    }
}

Upvotes: 1

Atais
Atais

Reputation: 11275

in 2020 you probably did not refresh the project in IDEA

because it actually works oob.

30 mins of reading outdated solutions :(

Upvotes: 3

vvj
vvj

Reputation: 1

ext {
    // path to IDEA generated sources directory
    ideaGeneratedSourcesDir = "$projectDir/src/main/generated"
}
compileJava {
    //……
    options.annotationProcessorGeneratedSourcesDirectory = file(ideaGeneratedSourcesDir)
    //options.headerOutputDirectory.set(file(ideaGeneratedSourcesDir)) (tested no effect)
    //……
}
// above work for me, and i try all method this question mentioned it's not work! env: idea2019.3, wrapped gradle6.3-all, zh-CN, JDK8, [x] annotation processing is disabled(no effect, in global settings ), no idea plugin([x]plugins {id idea}), [x]sourceSets no need to set(genereated srcDir)

myCodeGenExample:

task vertxCodeGen(type: JavaCompile) {
    group 'build'
    source = sourceSets.main.java
    destinationDir = file(ideaGeneratedSourcesDir)
    classpath = configurations.compileClasspath
    options.annotationProcessorPath = configurations.annotationProcessor
    options.debugOptions.debugLevel = "source,lines,vars"
    options.compilerArgs = [
            "-proc:only",
            "-processor", "io.vertx.codegen.CodeGenProcessor",
            // where the non Java classes / non resources are stored (mandatory) - the processors requires this option to know where to place them
            "-Acodegen.output=$destinationDir.absolutePath",
    ]
}

refresh the gradle, continously exist

Upvotes: 0

erwaman
erwaman

Reputation: 3547

In my case, it didn't work unless I added the generate sources directory to both sourceDirs and generatedSourceDirs:

def generatedSourcesDir = file('src/generated/main/java')
idea {
  module {
    sourceDirs += generatedSourcesDir
    generatedSourceDirs += generatedSourcesDir
  }
}

Upvotes: 5

jihor
jihor

Reputation: 2599

The code of this answer, rewritten using Kotlin DSL, will look like this:

plugins {
    idea
}

val generatedSourcesPath = file("out/production/classes/generated")

java.sourceSets["main"].java.srcDir(generatedSourcesPath)

idea {
    module {
        generatedSourceDirs.add(generatedSourcesPath)
    }
}

Upvotes: 18

Ophir Radnitz
Ophir Radnitz

Reputation: 1823

I'll point out a solution by Daniel Dekany, from a Gradle discussion thread actually linking to this question. To quote:

apply plugin: "idea"
...
sourceSets.main.java.srcDir new File(buildDir, 'generated/javacc')
idea {
    module {
        // Marks the already(!) added srcDir as "generated"
        generatedSourceDirs += file('build/generated/javacc')
    }
}

Works well for me.

Upvotes: 23

Related Questions