How to identify if a `KSTypeReference` is an aliased imported type? #2391

mcarleio · 2025-03-27T00:55:51Z

TLDR: How to (consistently) identify that a type is actually an aliased import?

Given the following code block

import kotlin.Double as FP

interface Mapper {
    fun fromFP(fp: FP): Int
    fun fromString(str: String?): Int?
}

And given the following simplified KSP code

ksClassDeclaration
            .getAllFunctions()
            .map {
                 isAlias(it.parameters.first().type)
            }

My current (frankly ugly and not optimal) way to identify if it is an alias:

fun isAlias(typeReference: KSTypeReference): Boolean {
    val resolvedType = typeReference.resolve()
    return typeReference.toString().takeWhile { it != '<' } != resolvedType.makeNotNullable().toString().takeWhile { it != '<' }
}

Sadly this is not working anymore since 2.1.20-1.0.32, as the typeReference is not anymore an instance of KSTypeReferenceImpl (1.0.31) but of KSTypeReferenceResolvedImpl (1.0.32), which has a different result for toString().

For fromFP:

With 1.0.31 the type is an instance of KSTypeReferenceImpl with toString() == "FP"
With 1.0.32 the type is an instance of KSTypeReferenceResolvedImpl with toString() == "Double"

I could amend the already ugly isAlias logic, but then I directly stumble upon similar problems with nullable types (see fromString) or even worse: a combination of nullable aliased import types with generics 😵

For fromString:

With 1.0.31 the type is an instance of KSTypeReferenceImpl with toString() == "String"
With 1.0.32 the type is an instance of KSTypeReferenceResolvedImpl with toString() == "String?"

The text was updated successfully, but these errors were encountered:

mcarleio · 2025-03-27T01:05:15Z

Background is, that I am writing a mapping library which will generate the implementation of those methods and I want to use the same names/aliases as the original code and not switch to the resolved types - although this will also work, but it can look very ugly when the alias e.g. was used due to colliding names.

override fun fromFP(fp: FP): Int = fp.toInt()
// vs
override fun fromFP(fp: Double): Int = fp.toInt()

ting-yuan · 2025-03-29T17:08:24Z

Although KSTypeReferenceResolvedImpl.toString() should render the alias rather than the underlying type (I consider it a minor bug), have you tried typeRef.resolve().declaration is KSTypeAlias which is more reliable than toString?

mcarleio · 2025-03-29T20:16:09Z

I think this will only work when those are typealiases. But in my case it is just an import alias (e.g. import kotlin.Double as FS), so typeRef.resolve().declaration is directly a KSClassDeclaration and not a KSTypeAlias.

Had a look with debugger on the KSTypeReferenceResolvedImpl with 1.0.32 and could not find any way to identify the import alias name.

mcarleio · 2025-04-05T09:01:31Z

@ting-yuan any further ideas or hints?

ting-yuan added this to the 2.0.1 milestone Apr 9, 2025

ting-yuan modified the milestones: 2.0.1, 2.0, 2.0.2 Apr 30, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

How to identify if a `KSTypeReference` is an aliased imported type? #2391

How to identify if a `KSTypeReference` is an aliased imported type? #2391

How to identify if a KSTypeReference is an aliased imported type? #2391

How to identify if a KSTypeReference is an aliased imported type? #2391

Comments

How to identify if a `KSTypeReference` is an aliased imported type? #2391

How to identify if a `KSTypeReference` is an aliased imported type? #2391