How to sync Java source and target between Gradle and Eclipse?

Question

Gradle has source Compatability and the targetCompatability variables that can be set. Eclipse has JDK compliance, generated class files comapatability, and source compatibility.

Is there any way to automagically set one from the other? Ideally, the Gradle stuff would be set from the Eclipse stuff.

edit: these things appear to be stored in: org.eclipse.jdt.core.prefs

edit2: they look like:

D:\ray\dev\conradapps\printg>cat .settings\org.eclipse.jdt.core.prefs eclipse.preferences.version=1 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve org.eclipse.jdt.core.compiler.compliance=11 org.eclipse.jdt.core.compiler.debug.lineNumber=generate org.eclipse.jdt.core.compiler.debug.localVariable=generate org.eclipse.jdt.core.compiler.debug.sourceFile=generate org.eclipse.jdt.core.compiler.problem.assertIdentifier=error org.eclipse.jdt.core.compiler.problem.enumIdentifier=error org.eclipse.jdt.core.compiler.release=disabled org.eclipse.jdt.core.compiler.source=1.8

i can make it work as follows, but it's a hack :)

import java.io.IOException;
import java.nio.file.*;
import java.util.*;
plugins {
    id 'java-library'
    id 'application'
    id 'distribution'
}

repositories {
    jcenter()
}
sourceCompatibility = '1.8'
targetCompatibility = '1.8'
dependencies {
    testImplementation 'junit:junit:4.12'
}
String myMainClass='p.Main'
jar {
  manifest {
    attributes(
      'Main-Class': myMainClass
    )
  }
}
application {
    mainClassName = myMainClass
}
class Hack {
    static String[] hack() throws IOException {
        System.out.println("Working Directory = "+System.getProperty("user.dir"));
        String dir="./.settings";
        String name="org.eclipse.jdt.core.prefs";
        File file=new File(dir,name);
        String[] strings=new String[3];
        for(int i=0;i<strings.length;i++)
            strings[i]="";
        if(file.exists()) System.out.println(file.toString()+" exists.");
        else return strings;
        List<String> lines=new ArrayList<>();
        try {
            if(usePath) {
                Path path=FileSystems.getDefault().getPath(dir,name);
                lines=java.nio.file.Files.readAllLines(path);
            } else {
                BufferedReader bufferedReader=new BufferedReader(new FileReader(file));
                for(String line=bufferedReader.readLine();line!=null;line=bufferedReader.readLine())
                    lines.add(line);
                bufferedReader.close();
            }
            int index;
            for(String line:lines) {
                if(line.startsWith("org.eclipse.jdt.core.compiler.compliance")) {
                    index=line.indexOf("=");
                    if(index>0) {
                        System.out.println("compliance: "+line.substring(index+1));
                        strings[0]=line.substring(index+1);
                    }
                }
                if(line.startsWith("org.eclipse.jdt.core.compiler.source=1.8")) {
                    index=line.indexOf("=");
                    if(index>0) {
                        System.out.println("source: "+line.substring(index+1));
                        strings[1]=line.substring(index+1);
                    }
                }
                if(line.startsWith("org.eclipse.jdt.core.compiler.codegen.targetPlatform")) {
                    index=line.indexOf("=");
                    if(index>0) {
                        System.out.println("target: "+line.substring(index+1));
                        strings[2]=line.substring(index+1);
                    }
                }
            }
        } catch(Exception e) {
            System.out.println("caught: "+e);
        }
        return strings;
    }
    public static void main(String[] args) throws IOException {
        hack();
    }
    static boolean usePath;
}
println("java version is: ${JavaVersion.current()}")
String[] strings=Hack.hack();
if(strings[1]!="") {
    println 'setting source'
    sourceCompatibility = strings[1]
}
if(strings[2]!="") {
    println 'setting target'
    targetCompatibility = strings[2]
}

Answer 1

Yes. If you want Gradle to give your configuration to Eclipse, basically, as of Gradle 5.1.1, just add:

sourceCompatibility = '1.7'
targetCompatibility = '1.8'

to your build.gradle file. Note that until java 10 the enumeration was 1.8,1.9,1.10 but from Java 11 and future versions the enumeration is 11, 12, etc. Check the Gradle docs. If you stumble upon this answer: For me, with Gradle 5.0, the java version works with or without quotes (either 1.8 or '1.8') and this is specified in the latest version of the javadocs. It also worked both when added inside and outside of compileJava{}. I tested this on a multiproject build.

I am not sure about the Eclipse to Gradle configuration transfer. Isn't it supposed to go the other way around though? Gradle is the central configuration tool that configures the build process and whatever IDE you are using (you, or your collaborator). Even if it is possible, the Gradle does manipulate the .classpath and other Eclipse files. So to be sure, if it was a crucial point, I would prefer to add the configuration to the Gradle and let that deal with Eclipse or any other IDE's files.