Check scope of the function call

[ppospisil-paylocity]

Hello team,

is it possible to check if a function call is inside a specific scope?

For example, let's say I want to invoke API calls only inside a helper function. One way to force this would be by context receivers, but these are deprecated, context parameters are not available yet, and this will require having context definition on every API method. With context receivers it would look like:

interface ApiCallScope

object ApiCallScopeInstance : ApiCallScope

fun apiCall(block: ApiCallScope.() -> Unit) {
    ApiCallScopeInstance.block()
}

interface Api {

    context(ApiCallScope)
    fun call()
}

val apiInstance: Api = object : Api {
    context(ApiCallScope)
    override fun call() {

    }
}

fun work() {
    apiCall {
        apiInstance.call()
    }
}

Would it be possible to check by ktlint if the call is in the ApiCallScope scope? Without the usage of context receivers?

Another way would be make all API methods extension functions on ApiCallScope, but it would require this run/apply construct which I would like to avoid.

interface ApiCallScope

object ApiCallScopeInstance : ApiCallScope

fun apiCall(block: ApiCallScope.() -> Unit) {
    ApiCallScopeInstance.block()
}

interface Api {
    fun ApiCallScope.call()
}

val apiInstance: Api = object : Api {
    override fun ApiCallScope.call() {}
}

fun work() {
    apiCall {
        apiInstance.run {
            call()
        }
    }
}

[paul-dingemans]

It doesn't look like something that ktlint can (nor should) support out of the box as the ApiCallScope is a custom concept that is probably only known in your code base. You can have a look at https://pinterest.github.io/ktlint/latest/api/custom-rule-set/ and try to implement a custom rule that you can rule with ktlint.

[ppospisil-paylocity]

Hello @paul-dingemans, thank you for the response. I didn't expect there would be a rule for dealing with my issue. I am just not sure if ktlint is capable of such a check with custom rules.

[paul-dingemans]

It depends, as always. From you examples I don't have a clear picture how flexible your solution needs to be. An important restriction of ktlint is that you can never use information outside of the file that you're processing. But if you can use hard coded information which is specific for your project than you can recognize any structure.

For example, the code below:

fun work() {
    apiCall {
        apiInstance.run {
            call()
        }
    }
}

can be represented in AST format (use PsiViewer plugin) as:

The higlighted element corresponds with the apiCall element in your code. With help of the PsiViewer you can explore the AST and write the rule for it.

[ppospisil-paylocity]

Hello @paul-dingemans, thank you for the response.

The code snippet you are commenting on is working now – there is no issue. But is it possible to check this of the apiCall lambda? I can't find the answer with the plugin.

When the helper function is defined like:

fun apiCall(block: ApiCallScope.() -> Unit) {
    ApiCallScopeInstance.block()
}

and called just like:

fun work() {
    apiCall { // Is it possible to check by ktlint the type of this (ApiCallScope) here?
        apiInstance.call()
    }
}