Interplay between inline constants and inline parameters

[artempyanykh]

Perhaps I'm missing something about how inline constants and inline params are supposed to work together. Below are a couple examples where compiler's behaviour is confusing. I expected inline vals to act like compile time constant (so that I could use them to build a DSL for some compile-time code generation), but it seems my intuition is not exactly correct.

Some clarification would be really helpful!

Compiler version

3.0.0-RC1

Simple example

object Str:
    inline def concat(inline a: String, inline b: String): String =
        ${ evalConcat('a, 'b) }
    
    def evalConcat(expra: Expr[String], exprb: Expr[String])(using Quotes): Expr[String] =
        val a = expra.valueOrError
        val b = exprb.valueOrError
        Expr(a ++ b)

// This works just fine
println(Str.concat("Hello, ", "Scala 3"))

inline val str1 = "Hello, "
inline val str2 = "Scala 3"
// While this doesn't compile with
// "Expected a known value". The value of: str1 could not be extracted using scala.quoted.FromExpr$PrimitiveFromExpr@4a8ebad7
println(Str.concat(str1, str2))

I'd expect that inline constant would get inlined at the use-site and both variants would work the same, but it seems that in the 2nd variant FromExpr sees str1 rather than its constant value "Hello, ".

More complex example

This is the setup. concat does compile-time concatenation of Bag contents.

case class Bag(things: Seq[Char])

object Bag:
    given ToExpr[Bag] with
        def apply(x: Bag)(using Quotes): Expr[Bag] =
            '{ Bag(${Expr(x.things)}) }

    given FromExpr[Bag] with
        def unapply(x: Expr[Bag])(using Quotes): Option[Bag] =
            x match
            case '{ Bag(${Expr(things)}) } => Some(Bag(things))
            case _ => None
    
    inline def concat(inline a: Bag, inline b: Bag): Bag =
        ${ evalConcat('a, 'b) }
    
    def evalConcat(expra: Expr[Bag], exprb: Expr[Bag])(using Quotes): Expr[Bag] =
        val a = expra.valueOrError
        val b = exprb.valueOrError
        val things = a.things ++ b.things
        Expr(Bag(things))

Then this works just fine

println(Bag.concat(Bag(Seq('a', 'b', 'c')), Bag(Seq('d', 'e')))) // => Bag(ArraySeq(a, b, c, d, e))

However, this doesn't compile:

inline val bagA = Bag(Seq('a', 'b', 'c'))
// inline value must have a literal constant type

This is somewhat confusing -- it's OK for Bag(Seq('a', 'b', 'c')) to be an argument to an inline parameter, why is it not OK for the same expression to be an RHS for an inline constant?

Furthermore, here the compilation error is no longer about RHS of an inline value, but it now complains about not being able to FromExpr.unapply argument bagA of Bag.concat.

inline val bagA = Bag(Seq('a', 'b', 'c'))
inline val bagB = Bag(Seq('a', 'b', 'c'))
println(Bag.concat(bagA, bagB))
// Error: The value of: bagA could not be extracted using org.scalex.Bag$given_FromExpr_Bag$@59323a86

The fact that the compilation error is not not about inline val but is rather about bagA argument is misleading.

[nicolasstucki]

What you want to use is

inline def bagA = Bag(Seq('a', 'b', 'c'))
inline def bagB = Bag(Seq('a', 'b', 'c'))
println(Bag.concat(bagA, bagB))

inline vals have the extra restriction that they need to literal constant values. This is checked by looking at the type of the inline val wich should be a singleton literal constant type. The error message could be better at guiding towards the correct code.

[nicolasstucki]

A simple way to see why inline val bagA is not allowed is in the following example.

inline val bagA = Bag(Seq('a', 'b', 'c'))
println(bagA)
println(bagA)

The question is how many times do you instantiate Bag? The val tries to indicate that it will only be instantiated once, but the inline states that it will be instantiated as many times as it used. If we use a def we do not have this conflict.

inline val works with constants because we can copy them around without having to instantiate anything.

[artempyanykh]

@nicolasstucki thanks for you response!

The val tries to indicate that it will only be instantiated once, but the inline states that it will be instantiated as many times as it used.

This actually clarifies things a great deal!

---

One more thing --

inline val works with constants because we can copy them around without having to instantiate anything.

Obviously, this should work with primitive types. However, what about Strings? I can assign a string constant to an inline val, but it behaves differently from when I assign the same constant to inline def, e.g.

This doesn't compile: error on line 3: The value of: str1 could not be extracted

inline val str1 = "Hello, "
inline val str2 = "Scala 3"
println(Str.concat(str1, str2))

While this does compile and works as expected:

inline def str1 = "Hello, "
inline def str2 = "Scala 3"
println(Str.concat(str1, str2))

My intuition is that inline val is a more restricted form of inline def. So if something works with inline def and I can assign my constant to inline val then things should work with inline val too.

[nicolasstucki]

A string is a special case, we do have a singleton type for String such as "Hello, " <:< String. We already use that to allow constant folding based on the type alone. In the case of inline strings, the strings themself are present in the bytecode and each instance is a pointer to that memory location. Hence, we do not really duplicate instances as we would do with a normal object.

My intuition is that inline val is a more restricted form of inline def. So if something works with inline def and I can assign my constant to inline val then things should work with inline val too.

Yes, your intuition is right.

[nicolasstucki]

This doesn't compile: error on line 3: The value of: str1 could not be extracted

inline val str1 = "Hello, "
inline val str2 = "Scala 3"
println(Str.concat(str1, str2))

that might be a bug

[nicolasstucki]

It is a bug, I will fix it in #11856

[artempyanykh]

Thanks @nicolasstucki, your help is much appreciated!