isInitialized - Backing field of lateinit var is not accessible at this point

Question

I'm trying to check if a lateinit property has been initialized.
In Kotlin 1.2 we now have the isInitialized method for that. It works when I do that in the class where the lateinit property is declared. But when I try to call this from another class I get the following warning:

Backing field of 'lateinit var foo: Bar' is not accessible at this point

My model class (let's say Person) is written in Java
Two other classes (let's say Test1 and Test2) are written in Kotlin

Example:

class Test1 {
    lateinit var person: Person

    fun method() {
        if (::person.isInitialized) {
            // This works
        }
    }
}

-

class Test2 {
    lateinit var test1: Test1

    fun method() {
        if (test1::person.isInitialized) {
            // Error
        }
    }
}

Any chance to get this working?

My current workaround is to make a method in Test1 which returns isInitialized from the person property.

fun isPersonInitialized(): Boolean = ::person.isInitialized

//in Test2:
if (test1.isPersonInitialized()) {
    // Works
}

I don't know the answer. But why you use `isInitialized` over nullable? `lateinit` show always be initialized before the object being use. — Joshua, Nov 29 '17 at 10:06
@Eledgy your code does not compile. you cannot put an if-expression directly in a class body. i think you forgot to wrap it inside an init block. i know, this does not fix your inital problem. — Willi Mentzel, Nov 29 '17 at 10:11
@Joshua I have one case where person may not be initialized yet — ElegyD, Nov 29 '17 at 10:19
@WilliMentzel It's just an example, I've put the code in a method — ElegyD, Nov 29 '17 at 10:21
@ElegyD Then, you should use `Person?`. If you abuse `lateinit`, you need an if everytime you access person which make you go back to Java with null checking. — Joshua, Nov 29 '17 at 10:25
I had the same issue using a `protected lateinit var` in a superclass and then calling isInitialized from a subclass. It seems like the underlying Java implementation is just wrapping the variable with `if(variable != null) {}` so this seems strange. — Victor Rendina, Dec 07 '17 at 13:48

score 103 · Answer 1 · answered Jul 10 '18 at 05:55

103

A really simple workaround to the constraints described by the accepted answer is the following:

class LateClass {
    lateinit var thing: Thing
    fun isThingInitialized() = ::thing.isInitialized
}

class Client {
    val lateClass = LateClass()
    ... things happen ...
    if (lateClass.isThingInitialized() {
        // do stuff with lateClass.thing, safely
    }
}

answered Jul 10 '18 at 05:55

AutonomousApps

4,229
4
32
42

3

Very nice and elegant. converted to property.. val isThingInitialized: Boolean = ::thing.isInitialized – Tejasvi Hegde Feb 10 '19 at 15:51
1

@TejasviHegde won't isThingInitialized be set to false on creation and never be updated to true once thing is initialized given that it is immutable? – Thomas Sunderland May 21 '19 at 18:17
@ThomasSunderland `isThingInitialized` is not immutable, it's a function. – AutonomousApps May 21 '19 at 20:13
@AutonomousApps I was speaking about Tejasvi's comment where they suggest that it can be a property and in their sample it is immutable – Thomas Sunderland May 22 '19 at 21:20
Is that preferred over var thing:Thing? = null? Why not instantiate to null? – portfoliobuilder Jun 28 '19 at 00:23
2

`val isThingInitialized: Boolean = ::thing.isInitialized` will always be false since is pre-calculated only once. You can make a function as in this solution, or make a lazy field: `val isThingInitialized: Boolean by lazy { ::thing.isInitialized }` – Xavier Arias Sep 06 '19 at 09:41
what if you don't have access to the super class? – Tamim Attafi Oct 19 '19 at 11:26
2

@TejasviHegde using a property can only be successful if you set up a getter to it. – Tamim Attafi Oct 19 '19 at 11:28
thanks for that work around --> I liked it. – Mina Samir Aug 09 '22 at 17:19

score 32 · Accepted Answer · answered Apr 07 '18 at 18:04

32

According to the docs:

This check is only available for the properties that are lexically accessible, i.e. declared in the same type or in one of the outer types, or at top level in the same file.

Which is why you cannot check that in the main function.

answered Apr 07 '18 at 18:04

Raghavendra

5,281
4
36
51

4

this should still be considered at kotlin v1.3.+ :) – Ric17101 Nov 17 '20 at 05:50

score 19 · Answer 3 · answered Aug 27 '20 at 07:04

19

My version as a Kotlin property.

class LateClass {
    lateinit var thing: Thing
    val isThingInitialized get() = this::thing.isInitialized 
}

answered Aug 27 '20 at 07:04

Sattar Hummatli

1,360
1
15
26

isInitialized - Backing field of lateinit var is not accessible at this point

3 Answers3

Linked