Sealed classes inside another class in Kotlin can't be compiled: cannot access '' it is private

Question

If I used the example from the docs,

class SomeActivity : AppCompatActivity() {
    sealed class Expr
    data class Const(val number: Double) : Expr()
    data class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}

it does not compile, with the error:

Cannot access '<init>', it is private in 'Expr'.

However, moving it outside the enclosing class makes it compile:

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

class SomeActivity : AppCompatActivity() {
}

Why is this so? Is this an intended behavior? The docs does not seem to mention this.

Think it's just the compiler restriction. From technical perspective, I don't see why sealed classes cannot be nested — Maxim, Jun 27 '18 at 08:31
Looks more like a bug than a restriction to me. If it's intended for some reason, at least the message should be fixed. — Alexey Romanov, Jun 27 '18 at 09:34

score 13 · Accepted Answer · edited Jun 20 '20 at 09:12

Yes, it turns out to be intended behavior. According to the proposal allowing non-nested subclasses:

Proposal: allow top-level subclasses for a top-level sealed class in the same file.

For a non top-level sealed class all subclasses should be declared inside it. So, for such classes nothing changes.

The scenario you want is listed as an open question. There is a ticket for it at https://youtrack.jetbrains.com/issue/KT-13495. Nobody seems to be working on it at the moment. In the discussion of the proposal, the developer says:

Well, there is some not-trivial implementations details(about generation synthetic constructors) which was solved for top-level classes but how do it in general is not clear.

score 2 · Answer 2 · answered Jun 27 '18 at 08:18

2

From the documentation:

A sealed class is abstract by itself, it cannot be instantiated directly and can have abstract members.

Sealed classes are not allowed to have non-private constructors (their constructors are private by default).

I guess the way you should use the example is like:

fun main(args: Array<String>) {
    val c = Const(5.0)
    val s = Sum(Const(1.0), Const(3.0))

    println(eval(c))
    println(eval(s))
}

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun eval(expr: Expr): Double = when(expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
    // the `else` clause is not required because we've covered all the cases
}

answered Jun 27 '18 at 08:18

Interesting thing is how this `Const(...) : Expr()` works if non-private constructors not allowed – Maxim Jun 27 '18 at 08:28
There you use Const's constructor. The limitation does not apply to classes that extend sealed classes. – Jun 27 '18 at 08:33
Yeah. For top-level sealed classes the compiler creates public constructor which is used internally, but for nested ones is not. – Maxim Jun 27 '18 at 08:40
@Maxim Wait, public? Not protected? – Alexey Romanov Jul 15 '18 at 12:46

score 2 · Answer 3 · edited Jul 07 '21 at 18:47

In Kotlin 1.0, the sealed functionality is rather restricted. For instance, all the subclasses must be nested, and a subclass can’t be made a data class ( data classes are covered later in this chapter). Kotlin 1.1 relaxes the restrictions and lets you define subclasses of sealed classes anywhere in the same file. In the given example, it is not allowed up until now. May be, in later release versions, they will relax this restriction. However, you can do this:

class SomeActivity {
    sealed class Expr {
        data class Const(val number: Double) : Expr()
        data class Sum(val e1: Expr, val e2: Expr) : Expr()
        object NotANumber : Expr()
    }
}

Sealed classes inside another class in Kotlin can't be compiled: cannot access '' it is private

3 Answers3

Linked