does anyone know if it is possible to annotate the instance created by the

companion object

, instead of the static class generated?

Hi, I'm watching logs of lots of CI builds with warnings from the kotlin compiler, did you thought on enabling some kind of reporting? I guess the cheskstyle format should work for you.

In our case we would then use our internal tooling to count them and notify the users, but I guess other tools would be able to do it too

Is there anyway require the target of an annotation be non-null-typed properties, parameters, etc.? I feel like I’ve seen something like this somewhere…

it seems like the kotlin compiler doesn't mind if

operator fun MyDelegate.setValue()

returns a type other than

Unit

(for use with delegated properties). does that mean the setter generated in JVM bytecode will also return something? even though this isn't something the compiler normally allows with a non-delegated property setter?

I'm asking because if it does then I think that technically means a java client could get a chaining API like

setBanana(value).setOtherThing(otherValue).etc()

if the setters return their thisRef

I'm trying to compile

libraries/tools/kotlin-main-kts

– do I really need all those JDK versions installed, and JDK 9 in particular? Debian only has JDK 8 and 11.

@channel, in case of someone is interested in Language Server Protocol implementation (Kotlin (JVM) and Kotlin/Native) - here is an invite: https://discord.gg/6f4RXD

https://twitter.com/kotlin/status/1249993403292618754 Want to add some code to your project? You don’t need to create a file for it first. Just copy the code, select the folder in the Project View in IntelliJ IDEA or Android Studio where you want to have it, and paste it. The IDE will automatically create a file for you. #KotlinTips https://t.co/fWNEbOXUKu Twitter

What's difference between 1.3.71 and 1.3.72?

0.0.01

the real answer is that we’ll get the release notes when they’re done and the release actually goes live

thx

How do I call super on a function that has a receiver?

https://twitter.com/kotlin/status/1250808679571623939 With kotlinx.serialization, you no longer need to have parameterless constructors for your data classes. Simply annotate these with @⁠Serializable. If you use Gradle/Maven though, make sure that you apply the corresponding Serialization plugin! #KotlinTips Twitter

say i have an object like:

object a {
  object b {
    const val one = 1
  }
  object c {
    const val two = 2
  }
}

is there any way to get the values

1

and

2

reflectively from

KClass<a>

ah, nm, i got it, can walk the

nestedClasses

Anybody else i18nizing a Kotlin project and care to share their experience? I'm missing the quick fixes from the Java i18n support and the "hard coded strings" inspection does not work everywhere. Here are my issues, please feel free to upvote 😉 https://youtrack.jetbrains.com/issue/KT-38346 https://youtrack.jetbrains.com/issue/KT-38344

Having an issue converting java to kotlin for some things with some advanced generics and co/contravariances We have this AbstractProjector

public abstract class AbstractProjector<ID extends Serializable, DTO extends AbstractView, DAO extends AbstractViewDao> {
    protected final JpaRepository<DAO, ID> repository;
    protected final Function<DAO, DTO> toDto;
    protected final Function<DTO, DAO> toDao;

    protected AbstractProjector(JpaRepository<DAO, ID> repository,
                                Function<DAO, DTO> toDtoFunction,
                                Function<DTO, DAO> toDaoFunction) {
        this.repository = repository;
        this.toDto = toDtoFunction;
        this.toDao = toDaoFunction;
    }
...

that is used like this:

public class WorkItemProjector extends AbstractProjector<WorkItemId, WorkItemView, WorkItemViewDao> {
    @Autowired
    public WorkItemProjector(WorkItemViewRepository repository) {
        super(repository, WorkItemViewDao::toDto, WorkItemViewDao::toDao);
    }
...
}

Here is the repository:

interface WorkItemViewRepository : JpaRepository<WorkItemViewDao?, WorkItemId?> {...}

Here is the

WorkItemView

and

WorkItemViewDao

data class WorkItemView(
    val workItemId: WorkItemId,
    val decisionId: SomeId,
    val appId: SomeId,
    override var tenantId: TenantId,
    val workItemStatus: WorkItemListType? = null
) : AbstractView, Serializable

@Entity(name = "…")
@Table(name = "…")
data class WorkItemViewDao(
    @Id var workItemId: WorkItemId,
    @AttributeOverrides(AttributeOverride(name = "id", column = Column(name = "…")))
    var decisionId: SomeId,
    @AttributeOverrides(AttributeOverride(name = "id", column = Column(name = "…")))
    var appId: SomeId,
    override var tenantId: TenantId,
    @Type(type = "Json", parameters = arrayOf(Parameter(name = "type", value = "…")))
    @Column(name = "data") var workItemView: WorkItemView
) : AbstractViewDao {
    companion object {
        @JvmStatic
        fun toDao(view: WorkItemView) = WorkItemViewDao(view.workItemId, view.decisionId, view.appId, view.tenantId, view)

        @JvmStatic
        fun toDto(dao: WorkItemViewDao?) = dao?.workItemView
    }
}

When converting this to Kotlin, you can guess the issue. AbstractProjector

abstract class AbstractProjector<ID : Serializable?, DTO : AbstractView?, DAO : AbstractViewDao?> protected constructor(
    protected val repository: JpaRepository<DAO, ID>,
    protected val toDto: (DAO) -> DTO,
    protected val toDao: (DTO) -> DAO
) {..}

WorkItemProjector

class WorkItemProjector(repository: WorkItemViewRepository) :
    AbstractProjector<WorkItemId?, WorkItemView?, WorkItemViewDao?>(
        repository,
        WorkItemViewDao::toDto,
        WorkItemViewDao::toDao
    ) {…}

and the issue is show in an image below. Here are some of the function signatures (in

AbstractProjector

) that demonstrate how I can’t effectively split this into multiple interfaces with different

out/in

variances (I think)

protected fun save(tenantId: TenantId?, viewCreator: () -> DTO) {
protected fun conditionallyUpdate(viewId: ID, proceedWithUpdate: (DTO) -> Unit, viewUpdater: (DTO) -> DTO) {
protected fun update(viewId: ID, viewUpdater: (DTO) -> DTO) {
protected fun update(daoSupplier: Supplier<DAO>, viewUpdater: (DTO) -> DTO) {
protected fun updateDao(viewId: ID, viewUpdater: (DAO) -> DAO) {
protected fun delete(viewId: ID) {
private fun update(viewDao: DAO, viewUpdater: (DTO) -> DTO) {

Any clue on this would be great.

Screen Shot 2020-04-17 at 2.25.31 PM.png

So I think we found a working solution, with marking differing generics with

?

.

https://github.com/square/AssistedInject Is AssistedInject dead? Last commit was nearly six months ago.

Hello you all, I have done a library for json manipulation https://github.com/Barddo/kson it's a Kotlin friendly fork of the org.json. Feel free to open issues and pull requests

Here is the List before deep copy:

This is what happening after running the deep copy on that list:

image.png

👋 I’m here! What’d I miss?

Would you tell me a simple project that can I make

New MockK 1.10.0 version released Posted in #mockk