scala.compiletime

Assertion that an argument is by-name. Used for nullability checking.

Returns the string representation of argument code:

inline def logged(inline p1: Any) =
  ("code: " + codeOf(p1), p1)

logged(identity("foo"))
// above is equivalent to:
// ("code: scala.Predef.identity("foo")", identity("foo"))

The formatting of the code is not stable across version of the compiler.

Given a constant, singleton type T, convert it to a value of the same singleton type. For example: assert(constValue[1] == 1).

Same as constValue but returns a None if a constant value cannot be constructed from the provided type. Otherwise returns that value wrapped in Some.

Given a tuple type (X1, ..., Xn), returns a tuple value (constValue[X1], ..., constValue[Xn]).

Use this method when you have a type, do not have a value for it but want to pattern match on it. For example, given a type Tup <: Tuple, one can pattern-match on it as follows:

type Tup
inline def f = {
inline erasedValue[Tup] match {
  case _: EmptyTuple => ???
  case _: (h *: t) => ???
}
}

This value can only be used in an inline match and the value cannot be used in the branches.

The error method is used to produce user-defined compile errors during inline expansion. If an inline expansion results in a call error(msgStr) the compiler produces an error message containing the given msgStr.

error("My error message")

or

inline def errorOnThisCode(inline x: Any) =
  error("My error of this code: " + codeOf(x))

Checks at compiletime that the provided values is a constant after inlining and constant folding.

Usage:

inline def twice(inline n: Int): Int =
  requireConst(n) // compile-time assertion that the parameter `n` is a constant
  n + n

twice(1)
val m: Int = ???
twice(m) // error: expected a constant value but found: m

Given a tuple T, summons each of its member types and returns them in a Tuple.

Summons first given matching one of the listed cases. E.g. in

type A
trait B
type C
inline def f = {
given B with { }

summonFrom {
  case given A => 1
  case given B => 2
  case given C => 3
  case _ => 4
}
}

the returned value would be 2.

Summon a given value of type T. Usually, the argument is not passed explicitly. The summoning is delayed until the call has been fully inlined.

Used as the initializer of a mutable class or object field, like this:

type T
var x: T = uninitialized

This signifies that the field is not initialized on its own. It is still initialized as part of the bulk initialization of the object it belongs to, which assigns zero values such as null, 0, 0.0, false to all object fields.