Why is the `const` keyword necessary? I understand...

# language-proposals

[Ellen Spertus]

Why is the const keyword necessary? I understand that const val is for compile-time constants and leads to different (presumably better) code than val, but why couldn't the compiler generate the better code if a [static] val is assigned a compile-time constant?

In other words, why does the compiler generate different code for these two lines?

const val PI = 3.1415
val PI = 3.1415

[ephemient]

Java does that and it's a terrible idea

[ephemient]

on the JVM, constant values are inlined everywhere they are used

[ephemient]

this means changing constant values is an API change - e.g. if I release a library with const val FOO = 1, somebody else builds a library using FOO, and then I release a new version with FOO = 2, a consumer of both libraries will see mismatched values

[ephemient]

(also within a multi-module Gradle build, this means that changing constant values forces Gradle to do additional work tracing every place where value got inlined, in order to recompile it, whereas changing a simple val does not change the API and dependents do not need to be recompiled)

[ephemient]

there are good reasons to use const - they're necessary for use in annotations, for example, which also explains why they are inlined - but it is a significant decision to make regarding your API

[ephemient]

https://wiki.sei.cmu.edu/confluence/display/java/DCL59-J.+Do+not+apply+public+final+to+constants+whose+value+might+change+in+later+releases

[ephemient]

see also how the Android build system generates

public class BuildConfig {
    public static final boolean DEBUG = Boolean.parseBoolean("true");

in order to create a static final but non-constant field

[sreich]

that's odd. why don't they just use = Boolean.TRUE ?

[sreich]

they're trying to trick the compiler, but isn't it effectively the same value?

[ephemient]

yes, forcing the compiler to unbox would also achieve the same goal, but they're also trying trick the IDE

[sreich]

what good does that do?

[sreich]

or, what does the IDE do that might be "wrong"?

[ephemient]

avoiding "could be constant" diagnostics

[sreich]

ah

[Norbi]

Just as a sidenote, this is somewhat related: https://youtrack.jetbrains.com/issue/KT-49303

[Norbi]

Just as a sidenote, the Zig language has very advanced compile-time evaluation: https://ziglang.org/learn/overview/#compile-time-reflection-and-compile-time-code-execution