Não é possível bytecode embutido criado com o destino da JVM 1.8 no bytecode que está sendo construído com o destino 1.6 da JVM

Ao tentar executar o exemplo CorDapp ( https://github.com/corda/cordapp-example ) via IntelliJ, recebo o seguinte erro:

Não é possível bytecode embutido criado com o destino da JVM 1.8 no bytecode que está sendo construído com o destino 1.6 da JVM

Como posso modificar as configurações do IntelliJ para que todo o bytecode seja construído com o mesmo destino da JVM?

app / build.gradle

android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = JavaVersion.VERSION_1_8.toString()
    }
}

GL

Use os recursos da linguagem Java 8

Você pode corrigir esse problema da seguinte maneira:

• Abra as preferências do IntelliJ
• Ir para Build, Execution, Deployment> Compiler> Kotlin Compiler MAS Other Settings > Kotlin compilerse Android contexto>3.4
• Mude Target JVM versionpara1.8
• Clique Apply

você deve configurar algo como a seguir em build.gradle

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

No meu caso, apenas alterar a Versão da JVM de destino da seguinte forma: Arquivo> Configuração> Compilador Kotlin> Versão da JVM de destino> 1.8 não ajudou. No entanto, ele resolveu o erro de tempo de compilação. Mas falhou no tempo de execução.

Eu também tive que adicionar o seguinte no arquivo build.gradle do aplicativo para fazê-lo funcionar.

 android {
     // Other code here...
     kotlinOptions {
        jvmTarget = "1.8"
     }
 }

Quando as outras soluções não funcionaram para você (Alterando a versão da JVM nas configurações do Compiler e adicionando jvmTargetà sua build.gradle), por causa de seus .imlarquivos tentarem forçar suas configurações, você pode alterar a plataforma de destino em Configurações do Projeto.

• Aberto File > Project Structure
• Vá para FacetsabaixoProject Settings
  • Se estiver vazio, clique no +botão pequeno
• Clique no seu módulo / módulos Kotlin
• Mude Target Platformpara JVM 1.8(também é melhor verificar a Use project settingsopção)

No meu caso, esse código não funcionou até eu passar apply plugin: 'kotlin-android'de baixo para cima.

apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'

android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

    kotlinOptions {
        jvmTarget = "1.8"
    }
}

No Android Studio 4.3.2, a adição do procedimento abaixo não está funcionando.

1. Abra as preferências do IntelliJ
2. Ir para Construir, Execução, Implantação > Compiler > Kotlin Compiler MAS Outras Configurações> compilador Kotlin se Android contexto> 3.4
3. Altere a versão da JVM de destino para 1.8
4. Clique em Aplicar

O motivo é que o Android studio não pode adicionar o código abaixo no arquivo Gradle no nível do módulo. Por favor, adicione-o manualmente.

kotlinOptions {
    jvmTarget = "1.8"
}

Apenas para o complemento, procure a versão Target JVM na pesquisa de estúdio do Android. O levará diretamente à opção.

uma imagem vale mais que mil palavras

Feb 2020
android 3.4+
Vá para Arquivo -> Configurações -> Compilador Kotlin -> Versão da JVM de destino> definido como 1.8 e, em seguida, certifique-se de fazer Arquivo -> Sincronizar projeto com arquivos Gradle

Ou adicione isso em build.gradle (module: app) no bloco android :

kotlinOptions {
           jvmTarget = "1.8"
         }

Como está escrito nos documentos using-maven do site da Kotlin:

Você só precisa colocar <kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>na seção de propriedades do seu pom.xml

Se você tiver muitos conjuntos de fontes / módulos, pode ser complicado configurar o jvmTarget para cada um deles separadamente.

Você pode configurar o jvmTarget para todos eles de uma vez da seguinte maneira:

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

Esse snippet pode ser usado no nível superior do seu arquivo gradle.build

Depois de modificar o arquivo gradle Reimport All Gradle Imports. Para verificar se funcionou, abra Project Structuree verifique se o IntelliJ foi atribuído corretamente JVM 1.8a todos os módulos Kotlin. Deve ficar assim:

Eu não recomendaria alterar a plataforma diretamente no IntelliJ, porque qualquer outra pessoa que clonar seu projeto pela primeira vez provavelmente enfrentará o mesmo problema. A configuração correta no gradle tem a vantagem de que o IntelliJ se comportará corretamente para eles desde o início.

No meu caso, resolvi isso seguindo estas duas etapas

1. Go to android studio preferences -> other settings -> kotlin compiler -> set Target JVM version = 1.8 
   if it doesn't work then go to the second option.

2. In your module-level build.gradle file add 
   compileOptions {
        sourceCompatibility = 1.8
        targetCompatibility = 1.8
    }
    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
        kotlinOptions {
            jvmTarget = "1.8"
        }
    }

Para mim, o motivo foi essa configuração no meu build gradle estar em alguns módulos e em alguns não

android {  
...      
kotlinOptions {
        val options = this as KotlinJvmOptions
        options.jvmTarget = "1.8"
    }
...
android {

Para Gradle com o idioma Kotlin ( *.gradle.ktsarquivos), adicione este:

android {
    [...]
    kotlinOptions {
        this as KotlinJvmOptions
        jvmTarget = "1.8"
    }
}

na maioria dos casos, isso é suficiente:

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

se você declarou tarefas Gradle personalizadas, como integrationTestpor exemplo, adicione uma configuração para compile<YourTaskName>Kotlin:

compileIntegrationTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

A configuração sourceCompatibility = JavaVersion.VERSION_1_8ativa a remoção de açúcar, mas atualmente não é possível remover todos os recursos do Java 8 que o compilador Kotlin usa.

Correção - a configuração kotlinOptions.jvmTarget to JavaVersion.VERSION_1_8no módulo de aplicativo Gradle resolveria o problema.

Use os recursos da linguagem Java 8: https://developer.android.com/studio/write/java8-support

android {
  ...
  // Configure only for each module that uses Java 8
  // language features (either in its source code or
  // through dependencies).
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
  // For Kotlin projects
  kotlinOptions {
    jvmTarget = "1.8"
  }
}

Todas as respostas aqui estão usando gradle, mas se alguém como eu acabar aqui e precisar de resposta para o maven:

    <build>
        <sourceDirectory>src/main/kotlin</sourceDirectory>
        <testSourceDirectory>src/test/kotlin</testSourceDirectory>

        <plugins>
            <plugin>
                <groupId>org.jetbrains.kotlin</groupId>
                <artifactId>kotlin-maven-plugin</artifactId>
                <version>${kotlin.version}</version>
                <executions>
                    <execution>
                        <id>compile</id>
                        <phase>compile</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                    <execution>
                        <id>test-compile</id>
                        <phase>test-compile</phase>
                        <goals>
                            <goal>test-compile</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <jvmTarget>11</jvmTarget>
                </configuration>
            </plugin>
        </plugins>
    </build>

A mudança do arquétipo do jetbrains para o kotlin-jvm é a <configuration></configuration>especificação do jvmTarget. No meu caso 11

Nada funcionou para mim até que eu atualizei minha dependência do plugin kotlin.
Tente o seguinte:
1. Invalide o cahce e reinicie.
2. Sincronize o projeto (pelo menos tente)
3. Vá em Arquivo -> Estrutura do projeto -> Sugestões
4. Se houver uma atualização referente ao Kotlin, atualize-a.
Espero que ajude alguém.

Se estiver usando o Visual Studio Code ** com extensão Kotlin, vá para o gerenciamento de plug-ins Crtl + Shift + x, digite kotlin e clique em gerenciar (a pequena engrenagem) >> Definir configurações de extensão

no Kotlin >> Compilador >> Jvm: Target - digite a versão java. Na minha situação, digitei 1,8

E então reinicie :-)

** vscode ou apenas 'code' para linux

No meu caso, Arquivo> Configuração> Compilador Kotlin> Versão da JVM de destino> 1.8

Estou usando o Kotlin e Gradle para o desenvolvimento normal da JVM, (não o Android) e isso funcionou para mim em build.gradle:

allprojects {
    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
        kotlinOptions.jvmTarget = JavaVersion.VERSION_11.toString()
    }
}

Se você usa o Eclipse, assumindo que baixou o plug-in Kotlin:

Clique com o botão direito do mouse em Projeto -> Propriedades -> Compilador Kotlin -> Ativar configurações específicas do projeto -> Versão de destino da JVM "1.8"

Para versões recentes do Android Studio, se a alteração apenas da versão da Kotlin Target VM não funcionasse.

Arquivo Structure Estrutura do projeto ➞ Módulos ( app): defina "Compatibilidade de origem" e "Compatibilidade de destino" para "1,8 (Java 8)". Pressione "OK" e sincronize o projeto com o Gradle.

se você estiver no projeto android

no build.gradle do seu aplicativo no Android {}

android{
//other configs...
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Usando o DSL Kotlin Gradle, isso resolveu o problema para mim. Eu adicionei isso ao build.gradle.kts. Isso é uma adição à resposta de Joel

val compileKotlin: KotlinCompile by tasks
compileKotlin.kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()

Outra dica para usuários do Eclipse. Após verificar novamente as configurações de destino da jvm apontadas por outros usuários, eu ainda tinha o mesmo problema, causado pela falta da Kotlin Runtime Library. Por exemplo, ao criar um projeto com spring initializr, ele não é adicionado automaticamente. Para adicioná-lo:right click on your project -> Build path -> Add libraries... -> User Library e simplesmente adicioneorg.jetbrains.kotlin.core.KOTLIN_CONTAINER

Atualize seu projeto de graduação posteriormente ( right click -> Gradle -> Refresh gradle project)

Se você estiver enfrentando esta mensagem em um projeto Spring Boot / Kotlin, defina a propriedade "kotlin.compiler.jvmTarget" como "1.8" no seu pom.xml.

    <properties>
        <kotlin.version>1.3.70</kotlin.version>
        <kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>
    </properties>
    ...

No meu caso, jvmTarget já estava definido no build.gradlearquivo como abaixo.

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

Mas meu problema ainda estava lá. Por fim, ele é resolvido após a alteração da versão da JVM de destino de 1.6 para 1.8 em Preferências> Outras configurações> Compilador Kotlin> versão da JVM de destino. veja a imagem em anexo,