I looked in the KEEP project and the Kotlin youtra...
# language-proposals
j
I looked in the KEEP project and the Kotlin youtrack and didn't see anything about this so I figure I'd propose it here: The current implementation of data classes is really nice, however, creating large data classes can end up creating large constructors. I really like them because they create nicely immutable bundles of data. In java, the builder pattern is usually utilized when constructors start to get large. However, the builder pattern can become quite clunky quickly, even when written by hand in kotlin. A developer could use the google auto-value annotation processor but I don't think this works with data classes. Plus its clunky and you have to deal with IDE configuration. In kotlin named parameters gets around this issue quite nicely because you can selectively specify the fields you want to assign. However, when creating a new instance of a data class in Java you end up with a very large constructor call without any way of knowing what fields you are assigning in the object when looking at the constructor. My proposal is that data classes get expanded to have a static
builder()
method on them that allows data classes created from java to use this builder. Default values that the data classes already have wouldn't be required to be specified in the builder. What are peoples thoughts on this? I'll open an issue in project KEEP if this is worthy of more feedback.
👍 2
e
So what is the problem with AutoValue? Why would you just use it if you need builders from Java?
j
You can't apply AutoValue to data classes. Data classes can't be abstract or have abstract methods.
e
I’d suggest, then, into looking at writing some kind of Kotlin compiler plugin that would generate this kind of builder pattern for Java interop based on some annotation like @JvmBuilder. This would be consistent with how other Jvm-interop annotations work (like @JvmOverloads, etc). This can be pulled off without having to change Kotlin as a language.
👍 2
j
I'd be more than happy to give this a shot. Is this worthy of KEEP or would it be standalone? Also, is there documentation about writing these compiler plugins? Setup and API documentation?
e
I mean, IMHO, working in this direction (plugin vs core change) has much more chances to succeed.
j
That makes lots of sense.
e
No docs on how to write them, but you can find KEEPs about other plugins, as well as examine how they are written. There is no stable public API, though, so in order to be stable this plugin will have to be contributed into Kotlin source tree
j
So you would propose that I merge this into the kotlin source branch instead of trying to host my own project on github?
Or would you start as an independent project and then try to port it to be merged in the the kotlin code base?
Also, is there an example that you can point (link) me to to provide a starting place?
Nvm. Found them
Given everything that I need to setup I'm going to try and do this within the kotlin repository.
v
Can't that be a separate annotator processor? Like auto value, but for kotlin
j
Annotation processors can't modify existing classes.
I'm not having much luck with executing the tests in any of the plugins. I want to write this using TDD and I can't seem to get my environment setup in such a way that I can write tests. Then write code to test it.
e
You’ll need to test from inside debug version of IDEA. Similar to what explained in “Compiling & running” https://github.com/JetBrains/kotlin#compiling-and-running (there is an “IDEA” run configuration to run a second instance of IDEA with your changes to the compiler)
j
?!?! Wow! That would kind of make sense. Can I do TDD easily or will I need to restart the IDE each time I make a change to the plugin?