@annyce probably #gradle could be a better place to ask

How difficult would it be to change

kotlinc

to read the package declaration on java sources to determine fq-names? Bonus question, how difficult would it be for us to pass arbitrary .java files instead of folders into

kotlinc-jvm

?

@dsyang passing individual .java files to

kotlinc

is supported since last week, you can either check out the dev build

1.1.4-dev-311

or later, or wait for the next EAP of 1.1.3 the issue is https://youtrack.jetbrains.com/issue/KT-17697

think i found it. -Dkotlin.compiler.execution.strategy="in-process"

same reason you disable the Gradle daemon on CI

of course now i'm getting a SIGSEGV from the JVM by moving it in process so ¯\_(ツ)_/¯

it would be nice if the gradle plugin would detect the jre version based on the stdlib artifact being used and update all the kotlin compile tasks to the appropriate jvm target

Is there a JB hosted maven repo? I'm looking for a repo that hosts "intellij-core-analysis"

Looking at this again, it seems like the Kotlin compiler daemon takes care of cleaning itself up if the Gradle build is run without using the Gradle daemon. It's only when the Gradle build terminates abnormally that the Kotlin compiler daemon seems to stick around.

We would like to understand extension functions a bit better. How does the compiler know they are available? We have a class transformer in place as part of our Gradle plugin, and after that step extensions functions raise compiler errors when used from another module. (Context: https://github.com/greenrobot/ObjectBox/issues/134)

anyone using Android Studio 3.0 Beta2? and facing error with 'kotlin-kapt' and dagger2? everytime if I change the dagger tree I have to clean the project or project wont compile where do I report a bug for kapt actually? 😄

I’ve tried

detekt

and

ktlint

. Do you know if there is anything else?

assuming they are just data classes and don’t house any logic it would be best to ignore them in both your testing efforts as well as your coverage report.

@yan you or someone in JB might be interested to know about this (from the ASG Slack):

Hi folks, we have started to work on incremental annotation processing together: Gradle, Groupon and Google.

We have a draft of our first milestone spec. Please feel free to review it and give your constructive feedback 😉

https://docs.google.com/document/d/1CXNfKmPx9hqfnGWic3F9sKHQ6T8ImDVxnXfkvWYqwxg/edit?usp=sharing

Slack Conversation

Hello all 🙂 Is there a way to "speed up" editing

.gradle

files in IntelliJ? It gets stuck for a few second when I type each character, like it's saving/reloading.. Very frustrating Also, Gradle eats up my RAM incrementally, I think I messed my setup 😕 Do you have any advice regarding these issues? Thanks! K

JB people, can you please explain performance differences between running Gradle build with separate Kotlin Compiler Daemon vs in-process compilation? What is the lifecycle of in-process compilation? Isn’t Gradle daemon enough to keep compiler “hot” (class loading, JIT)? Thanks! --- Reason why I’m asking is because we’re facing issues with Kotlin Compiler Daemon with a single Kotlin module in project when we build it with

--parallel

, see

<https://youtrack.jetbrains.com/issue/KT-15562#comment=27-2494744>

I’m facing random compiling error on CI. The same code may compile successfully and after adding git tag (which triggering new CI check) the same code fails to build with error

Gradle build daemon disappeared unexpectedly (it may have been killed or may have crashed)

. I’ve tried to add different params to build command, but this didn’t help. Adding

-Dkotlin.compiler.execution.strategy=in-process

broke android data binding annotation processing. My current gradle build command looks like this:

./gradlew -Pkotlin.incremental=false -Dorg.gradle.parallel=false -Dorg.gradle.daemon=false testBetaQaUnitTest lintBetaQa testProdReleaseUnitTest lintProdRelease

@ilya.gorbunov I’ve tried but no luck yet. See http://holgerbrandl.github.io/krangl/javadoc/krangl/krangl/builder.html for the result, and for the corresponding source https://github.com/holgerbrandl/krangl/blob/master/src/main/kotlin/krangl/Builder.kt#L45 . From what I can see the referenced sample should be fine as well (see https://github.com/holgerbrandl/krangl/blob/master/src/main/kotlin/krangl/samples/DokkaSamples.kt#L13)

Between Kotlin 1.1.51 and 1.1.60

kotlin-annotation-processing

artifact was discontinued and now there is a

kotlin-annotation-processing-gradle

instead (as well as

-maven

which was there for some time)

<https://github.com/JetBrains/kotlin/commit/feee93186bdab504c5bf94d1c046bf7f2a0697af>

1. Does it mean that

-gradle

version will become more Gradle-specific? Reason why I'm asking is because OkBuck + Buck need it to support Kapt and relied on

kotlin-annotation-processing

before, but now it's gone 2. Changelog doesn't seem to reflect this change

<https://github.com/JetBrains/kotlin/blob/1.1.60/ChangeLog.md>

cc @h0tk3y

the 30 seconds should only be spent on the first build. incremental build should only rebuild the files you changed

Do kotlin/kotlinc require a jdk or do they work also with “just” a jre?

Hey, with gradle kotlin scripts, one of the things that I find a bit toooo noisy compared to plain groovy gradle scripts, is the necessity to put in

${property("foo")}

inside dependencies definitions, i.e.,

compile("com.google.protobuf:protobuf-java:${property("protobufVersion")}")

I know there is another way of defining the var inside the kts file,

var foo="1.2"

then using

$foo

inside the dependency definition. The latter being more "groovy" like (without the var definition). Is there no shorter way of expressing this?

I am attempting to build the Kotlin Gradle Plugin from source and I have grabbed the latest version off of Github. In the instructions it says

For local development, if you’re not working on bytecode generation or the standard library, it’s OK to have only JDK 8 installed, and to point all of the environment variables mentioned above to your JDK 8 installation.

When I do that I get the following error:

A problem occurred configuring root project 'kotlin'.
> Invalid environment value JDK_16: "/Library/Java/JavaVirtualMachines/jdk1.8.0_92.jdk/Contents/Home", expecting JDK home path

What am I doing wrong here?

Does kapt support incremental builds?

Gradle now uses separate output directories for each JVM language, but this build assumes a single directory for all classes from a source set. This behaviour has been deprecated and is scheduled to be removed in Gradle 5.0

Is this something, the JB guys are aware of? Would be kinda awkward if the Kotlin plugin stopped working with Gradle 5.0

Trying to compile passing the same module-name for both compilation invocations of main and test and the error still happens 😕

Sharing here as well due to still be related and having way more people then #compiler channel. Hoping someone knows this 😄

Any news here? Is there someone from the kt team that can help me?

Does anyone knows how a build file xml should look like?

Or the normal flow of gradle would be to use kotlinc to compile sources (without creating the jar) and them zip everything together later on?