How can I enforce that a class has a companion object?

Question

What I want is this:

interface base {
  abstract static fun foo()
}

class impl : base { 
  override static fun foo()
}

Normally, Kotlin solves problems using companion objects rather than static functions. But an interface can't define a requirement for a companion object with function. So how can I accomplish this? The code that uses this would look like

fun <T : base> bar() {
  T.foo()
}

Any other way to get this behavior? Namely, that I can execute a function of a derivative of T, without knowing the specific type, and not assuming the derivative has a default constructor?

Edit

I was able to get this to do what I want by using value parameters of types that can be set on the companion objects of the classes I want to work with. An illustrative example of what I want to use this technique for.

import kotlin.reflect.full.*

interface DynamicBuilder {
    fun build(sides: Int): Shape?
}

interface Shape {
    companion object : DynamicBuilder {
        override fun build(sides: Int) = null
    }
}

abstract class Shape2D : Shape {
    companion object : DynamicBuilder {
        override fun build(sides: Int) = if(sides > 0) Square() else Circle()
    }
}

abstract class Shape3D : Shape {
    companion object : DynamicBuilder {
        override fun build(sides: Int) = if(sides > 0) Cube() else Sphere()
    }
}

class Square : Shape2D()
class Circle : Shape2D()
class Sphere : Shape3D()
class Cube : Shape3D()

fun Build(sides: Int, builder: DynamicBuilder): Shape? {
    return builder.build(sides)
}

inline fun <reified T : Shape> Build(sides: Int): Shape? {
    return Build(sides, T::class.companionObjectInstance as DynamicBuilder)
}

fun main() {
    println(Build(0, Shape2D))
    println(Build(4, Shape2D))

    println(Build<Shape3D>(0))
    println(Build<Shape3D>(6))
}

The goal is that I can create a new entire class of Shape, and have all the logic related to how it builds the concrete object contained in that file, rather than having some monolithic shared switch statement.

Answer 1

An interface can define a requirement for some object with function, and you can suggest it to be the companion object even if you can't force it to be.

interface BaseCompanion {
    fun foo(): Unit
}

interface Base {
    companion object : BaseCompanion {
        fun foo() { println("in Base") }
    }

    fun companion(): BaseCompanion = Base
}

interface Derived : Base {
    companion object : BaseCompanion {
        fun foo() { println("in Derived") }
    }

    override fun companion() = Derived
}

// value parameter, not type parameter
fun bar(companion: BaseCompanion) {
    companion.foo()
}

bar(Base)
bar(Derived)

The companion() function isn't actually used in this case, it's for when you want to access the companion from a Base instance:

fun baz(x: Base) {
    x.companion().foo()
}

Another (unsafe) option is to define companion() using reflection.

fun companion() = this::class.companionObjectInstance as BaseCompanion

Plus: no need to explicitly override it in Derived; minuses: 1. will crash at runtime if you forget to create the companion or to extend BaseCompanion; 2. slower than non-reflection definition.

Answer 2

TL;TR:

• How can I enforce that a class has a companion object?
• You cannot.

Kotlin has no static methods. Even if it had them, they wouldn't be overridable, as they are not in Java. The same holds for companion objects. Kotlin code is eventually compiled to Java byte code, so what is not possible in Java won't be possible in Kotlin either.

Edit:

It's interesting to see what the compiler has to say about it. Consider the following snippet:

open class Base {
    companion object {
        fun test() {}
    }
}

inline fun <reified T : Base> staticCall() {
    T.test() // <-- ERROR
}

The error message:

Type parameter 'T' cannot have or inherit a companion object, so it cannot be on the left hand side of dot

Answer 3

Based on your updated question, it seems like what you want is usually achieved using the factory pattern. Alternatively you could also use dependency injection. There are many options without the usage of reflection.

Why shouldn't you use reflection?

There are a few reasons here and here and you can find more if you google it. Generally reflection was created for a specific purpose, to discover the functionality of a class that was unknown at compile time. You do not use it for this purpose, since your implementation requires you to know the class, in order to pass it as a reified generic parameter. If you do require to discover classes that you don't know at compile time, you can use dependency injection.

The simpler solution for your version is a factory pattern:

interface Shape
class Square : Shape
class Circle : Shape
class Sphere : Shape
class Cube : Shape

object ShapeFactory {
    fun build2DShape(sides: Int): Shape {
        if(sides > 0) Square() else Circle()
    }

    fun build3DShape(sides: Int): Shape {
        if(sides > 0) Cube() else Sphere()
    }
}

fun main() {
    println(ShapeFactory.build2DShape(0))
    println(ShapeFactory.build3DShape(0))
}

In short, Build<Shape3D>(0) is replaced by ShapeFactory.build3DShape(0). The caller still has to know that there are 3DShapes and where they are. The only thing that changed is that you do not require Reflection.

This requires the person calling the function to know of the existence of 2D and 3D shapes. Same as in your implementation with reflection. This way you can have all the logic how to create the shapes in the same file as the shapes. You could even make the factory call some functions in the companion object of the shape if you wish to do so. Your factory knows of the existence of those subclasses. But since you can put the factory in the same file as the subclasses, that doesn't split the logic to somewhere else.

If you want to delegate the deciding whether it is a 2D or a 3D shape to a subclass you can do the following:

interface Shape
class Square : Shape
class Circle : Shape
class Sphere : Shape
class Cube : Shape

object ShapeFactory {
    fun build2DShape(sides: Int): Shape {
        return if(sides > 0) Square() else Circle()
    }

    fun build3DShape(sides: Int): Shape {
        return if(sides > 0) Cube() else Sphere()
    }
}

fun getBuilder(dimensions: Int): (sides: Int) -> Shape {
    if (dimensions == 2)
        return ShapeFactory::build2DShape
    else 
        return ShapeFactory::build3DShape
}

fun main() {
    print (getBuilder(2)(3))
}