Gson TypeAdapter & Factory generator for Kotlin data classes

Hello. When I am trying to generate TypeAdapter for class with companion object and some constants in this object I have an error because TypeAdapter tries to write and read static field and companion field from JsonObject

Support for https://github.com/aafanasev/kson/issues/5

So, what's going on is:

1. To support incremental compilation all files created by annotation processor have to be created using Filer. To do so I have to update KotlinPoet to latest version (1.3.0) which led to some methods being removed, moved or changed visibility. Thus, I created file KotlinPoetExtensions.kt with some extension methods to match old api.
2. Another thing is we should provide originating element to all files, so I have to change some methods to work with TypeElement instead of ClassName.
3. I have to update Kotlin to version 1.3.40 because of this bug.
4. For better performance I split processor into two: one for generating TypeAdapter (this one is ISOLATING) and one for generating TypeAdapterFactory (this one is AGGREGATING).
5. I also use AutoService to register annotation processors which is more convenient imo.

@Kson
data class UserEntity(
    val firstname: String, 
    val lastname: String
)

// generated code
...
private val firstnameAdapter by lazy { gson.getAdapter(String::class.java) }  
private val lastnameAdapter by lazy { gson.getAdapter(String::class.java) }  
...

As you see, each property will have it's own adapter. I think better to have adapters grouped by types, f.ex:

private val stringAdapter by lazy { gson.getAdapter(String::class.java) } 

and use this adapter in both properties

Now generated code looks like this:

private val adapter by lazy { gson.getAdapter(...) }

Since the evaluation of the delegated properties is synchronized and it's redundant in TypeAdapter case, need to use LazyThreadSafetyMode.NONE mode, which doesn't incur any thread-safety guarantees and the related overhead.

gson-extras has such class: https://github.com/google/gson/blob/master/extras/src/main/java/com/google/gson/typeadapters/RuntimeTypeAdapterFactory.java which is helpful for polymorphic types serialization without reflection.

For example, it can be used to handle Kotlin sealed class serialization:

sealed class Shape {
        class Rectangle() : Shape()
        class Circle() : Shape()
}

val adapter: RuntimeTypeAdapterFactory<Shape> = RuntimeTypeAdapterFactory.of(Shape::class.java)
        .registerSubtype(Rectangle::class.java)
        .registerSubtype(Circle::class.java)

And then in your gson instance builder:

registerTypeAdapterFactory(adapter)

However, seems it is a boilerplate and not safe solution to write such factory for every sealed class in the project. Would be nice to handle it with annotations like kotlinx-serialization does with polymorphic serialization problems: https://medium.com/@andreclassen1337/goodbye-runtimetypeadapterfactory-polymorphic-serialization-using-kotlinx-serialization-46a8cec36fdc

@Polymorphic
sealed class Shape {
        @SerialName("Rectangle")
        class Rectangle() : Shape()
        @SerialName("Circle")
        class Circle() : Shape()
}