CODEWITHSUNDEEP
gradlekotlin
wst
wst

Reputation: 4338

How to set up Kotlin's byte code version in Gradle project to Java 8?

In Kotlin project, what is a proper Gradle script to make sure my classes will be compiled to byte code ver 52 (Java 8)?

For some reason my classes are compiled as ver 50 (Java 6) even though I set up source and target compatibility. At least this is what Idea shows me when I open file from directory build/classes/... after building the project.

My current set up looks like this.

buildscript {
    ext {
        kotlinVersion = '1.0.5-2'
        springBootVersion = '1.4.2.RELEASE'
    }
    repositories { mavenCentral() }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
    }
}

apply plugin: 'kotlin'
apply plugin: 'org.springframework.boot'

tasks.withType(JavaCompile) {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

// I also tried this and it hasn't helped
//sourceCompatibility = 1.8
//targetCompatibility = 1.8

repositories { mavenCentral() }

dependencies {
    compile("org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}")
    compile('org.springframework.cloud:spring-cloud-starter-stream-rabbit')
}

dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:Camden.SR2" } }

Upvotes: 89

Views: 82268

Answers (12)

hennr
hennr

Reputation: 2762

Since gradle 6.7 there is so called java toolchain support in gradle which I find easiest to use.

It allows you to configure the JDK to use for this project and will even download the required version if needed.

All you need is a compatible JRE to start gradle and this block in your gradle build file:

kotlin dsl

kotlin {
    jvmToolchain {
        // for gradle kotlin plugin < 1.7:
        (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(17))
        // for gradle kotlin plugin >= 1.7:
        languageVersion.set(JavaLanguageVersion.of(17))
    }
}

groovy dsl

kotlin {
    jvmToolchain {
        languageVersion.set(JavaLanguageVersion.of(17))
    }
}

Note: This will update the java compiler settings as well, so you don't need anything else in your build.gradle.kts

Read more about this in the docs:

https://kotlinlang.org/docs/gradle.html#set-custom-jdk-home

https://docs.gradle.org/current/userguide/toolchains.html

Also note that you need to pull in a plugin to download the JDK if you want to use this feature as well.

Upvotes: 8

Igor Mukhin
Igor Mukhin

Reputation: 15368

New syntax for konlin-dsl:

import org.jetbrains.kotlin.gradle.dsl.JvmTarget

plugins {
    `kotlin-dsl`
}

repositories {
    mavenCentral()
}

java {
    targetCompatibility = JavaVersion.VERSION_20
}


kotlin {
    compilerOptions {
       jvmTarget.set(JvmTarget.JVM_20)
    }
}

Upvotes: 2

Marko Bonaci
Marko Bonaci

Reputation: 5708

I tried all of the above and I was still getting warnings for compileTestKotlin.
This is what cleared all of them in the root build.gradle:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile).all {
  kotlinOptions {
    jvmTarget = 17
  }
}

Upvotes: 1

nazmul idris
nazmul idris

Reputation: 442

If you're getting an error like this: Cannot inline bytecode built with JVM target 1.8 into bytecode that is being built with JVM target 1.6. Please specify proper '-jvm-target' option.

Then, you can simply add the following in build.gradle (in Groovy) in order to tell kotlin to build using 1.8.

compileKotlin {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Upvotes: 1

Dmitry Kaltovich
Dmitry Kaltovich

Reputation: 2270

In your build.gradle.kts:

    tasks {
        val java = "11"

        compileKotlin { 
           kotlinOptions { jvmTarget = java }
           sourceCompatibility = java
        }
    }

Or like this:

tasks {
    withType<KotlinCompile> { kotlinOptions { jvmTarget = "11" } }
}

Upvotes: 11

Igor
Igor

Reputation: 2089

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

// JVM target applied to all Kotlin tasks across all subprojects

// Kotlin DSL
tasks.withType<KotlinCompile> {
    kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()
}

//Groovy
tasks.withType(KotlinCompile) {
    kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8
}

Upvotes: 19

tanpengsccd
tanpengsccd

Reputation: 2129

thx for seanf's anwser ,but if your DSL kotlin is 1.3.0: 

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class.java).all {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Upvotes: 1

guenhter
guenhter

Reputation: 12167

In case someone uses gradle with kotlin-dsl instead of groovy:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

// compile bytecode to java 8 (default is java 6)
tasks.withType<KotlinCompile> {
    kotlinOptions.jvmTarget = "1.8"
}

Upvotes: 79

seanf
seanf

Reputation: 6734

As Mark pointed out on Debop's answer, you have to configure both compileKotlin and compileTestKotlin. You can do it without duplication this way:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
  kotlinOptions {
    jvmTarget = "1.8"
  }
}

For a pure Kotlin project, I don't think the options sourceCompatibility and targetCompatibility do anything, so you may be able to remove them.

Ref: https://kotlinlang.org/docs/reference/using-gradle.html#compiler-options

Upvotes: 116

happy15
happy15

Reputation: 79

For anyone like me who use maven to build mixed code of kotlin and java in intellij , you need to set 

<kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>

because maven build doesn't respect jvmTarget set in project setting.

Upvotes: 1

Debop
Debop

Reputation: 1075

Kotlin 1.1 in Gradle. in console you have error about inline (your installed compiler is 1.0.x) If run gradle task in IntelliJ IDEA, your code compiled by kotlin 1.1 compiler

compileKotlin {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8

    kotlinOptions {
        jvmTarget = "1.8"
        apiVersion = "1.1"
        languageVersion = "1.1"
    }
}

Upvotes: 42

Ingo Kegel
Ingo Kegel

Reputation: 47995

Kotlin 1.0 always produces Java 6 class files. Kotlin 1.1 will support generating Java 8 class files by passing -jvm-target 1.8 to the compiler. See

https://blog.jetbrains.com/kotlin/2016/07/first-glimpse-of-kotlin-1-1-coroutines-type-aliases-and-more/

for a discussion of Java 7/8 support.

Upvotes: 7

Related Questions