A problem with build task and sourceCompatibility = 1.7, gradle 5.3

Question

I use sourceCompatibility = 1.7 in gradle.properties, Gradle JVM(Settings, Gradle, Intellij IDEA) is 1.8.0_171 and

wrapper {
    gradleVersion = '5.3'
    distributionType = 'ALL'
}

in build.gradle.

When I run build task(Tasks->build->build Intellij IDEA) I get "error: incompatible types: inferred type does not conform to equality constraint(s)" during compileJava task.

If I set up Gradle JVM is 1.7.0_80 and

wrapper {
    gradleVersion = '4.3'
    distributionType = 'ALL'
}

build is fine.

What I'm doing wrong? How can I build JAVA 7 project using gradle 5.3?

Answer 1

This is probably caused by a subtle change in the type-checking rules for generics between Java 7 & Java 8 as described in Why does this program compile with Java 7 but not Java 8?

So what is the solution?

I doubt you will find a magic compiler switch or something to just make it work. Realistically, I think that your choices are:

1. You could just compile on a Java 7 platform as you did to start with. But this is not a good long-term solution.

2. If this is a supported product, lodge a support request.

3. If this is an open source product, check the product's issue checker to see if someone has already reported the problem. They may have reported a fix as well.

4. Look at the source code that you are trying to compile, identify the cause of the compilation error and fix it. If this is an open source product, submit your fix as a patch.

Note that it is possible that these compilation errors are reporting a latent bug that could under some circumstances lead to unexpected runtime exceptions.

---

You said:

I thought sourceCompatibility = 1.7 will set up java 7 for compile *.java.

It does. However, there are degrees of compatibility.

When you run a Java 8 compiler with -source 1.7 you are actually just turning off support for new language features. Under the hood, the compiler is still a Java 8 compiler. If there have been subtle changes in (for example) the type checker, it is plausible that the Java engineers did not implement a backwards compatibility mode for the old behavior.

(The extra mode may make an already complex piece of software too difficult to maintain. Type checking and type inference is one of the more difficult aspects of compiler implementation.)