Make inline val transparent

Inline vals aim to be a replacement of final vals with inferred literal types.
They inline by having a literal type as a return type.

In inline def terms, this is equivalent to transparent inline def returning the constant which is also stable.
```
inline val x = 3
transparent def y: Int = 3
```

Therefore, such a definition of an inline val is always a transparent inline.
```
/*transparent*/ inline val x = 3
```

If we define inline vals as always being transparent inline vals, then the constant type becomes an implementation detail rather than a restriction. This would imply that the following inline val are allowed.
```
inline val a: Byte = 1
inline val b: Short = 2
inline val c: Int = 3
```
Note that with literal types it is impossible to directly implement `a` and `b` as those need a type annotation to infer their type, but the type would be widened.

New `inline val` definition:
* An `inline val` is `transparent`
* An `inline val` is `final` or `abstract`
* The RHS of an `inline val` must be a pure constant value

Advantages
* Aligns better with inline defs
* Can define constant `Byte` and `Short`

The proposed implementation would just reuse the same literal constant mechanism but modify slightly type inference for inline vals. When we type an inline val we use the return type
to type/infer the type of the RHS, but then if the return type is not a constant, the return
unwidened type is replaced by the type of the RHS.

```
inline val x: Int = 3
// typed as
inline val x: 3 = 3
```

Author: nicolasstucki

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -882,18 +882,24 @@ trait Checking {
     }
   }
 
-  /** Check that `tree` can be right hand-side or argument to `inline` value or parameter. */
-  def checkInlineConformant(tpt: Tree, tree: Tree, sym: Symbol)(using Context): Unit = {
+  /** Check that `tree` can be right hand-side or argument to `inline` value.
+   *  Returns the type (tpt) of the val, possibly adapted.
+   */
+  def checkInlineConformant(tpt: Tree, tree: Tree, sym: Symbol)(using Context): Tree = {
     if sym.is(Inline, butNot = DeferredOrTermParamOrAccessor) && !ctx.erasedTypes && !ctx.inInlineMethod then
-      // final vals can be marked inline even if they're not pure, see Typer#patchFinalVals
-      val purityLevel = if (sym.is(Final)) Idempotent else Pure
-      tpt.tpe.widenTermRefExpr.dealias match
+      tree.tpe.widenTermRefExpr.dealias match
         case tp: ConstantType =>
+          // final vals can be marked inline even if they're not pure, see Typer#patchFinalVals
+          val purityLevel = if (sym.is(Final)) Idempotent else Pure
           if !(exprPurity(tree) >= purityLevel) then
-            ctx.error(em"inline value must be pure", tree.sourcePos)
+            ctx.error("inline value must be pure", tree.sourcePos)
+          if tree.tpe =:= tpt.tpe then tpt
+          else TypeTree(tree.tpe).withSpan(tpt.span)
         case _ =>
-          val pos = if tpt.span.isZeroExtent then tree.sourcePos else tpt.sourcePos
-          ctx.error(em"inline value must have a literal constant type", pos)
+          ctx.error("inline value must have a literal constant type", tree.sourcePos)
+          tpt
+    else
+      tpt
   }
 
   /** A hook to exclude selected symbols from double declaration check */
@@ -1222,7 +1228,7 @@ trait NoChecking extends ReChecking {
   override def checkImplicitConversionDefOK(sym: Symbol)(using Context): Unit = ()
   override def checkImplicitConversionUseOK(sym: Symbol, posd: Positioned)(using Context): Unit = ()
   override def checkFeasibleParent(tp: Type, pos: SourcePosition, where: => String = "")(using Context): Type = tp
-  override def checkInlineConformant(tpt: Tree, tree: Tree, sym: Symbol)(using Context): Unit = ()
+  override def checkInlineConformant(tpt: Tree, tree: Tree, sym: Symbol)(using Context): Tree = tpt
   override def checkNoAlphaConflict(stats: List[Tree])(using Context): Unit = ()
   override def checkParentCall(call: Tree, caller: ClassSymbol)(using Context): Unit = ()
   override def checkSimpleKinded(tpt: Tree)(using Context): Tree = tpt

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1801,9 +1801,9 @@ class Typer extends Namer
       case rhs @ Ident(nme.WILDCARD) => rhs withType tpt1.tpe
       case rhs => typedExpr(rhs, tpt1.tpe.widenExpr)
     }
-    val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
+    val tpt2 = checkInlineConformant(tpt1, rhs1, sym)
+    val vdef1 = assignType(cpy.ValDef(vdef)(name, tpt2, rhs1), sym)
     checkSignatureRepeatedParam(sym)
-    checkInlineConformant(tpt1, rhs1, sym)
     patchFinalVals(vdef1)
     vdef1.setDefTree
   }

docs/docs/reference/metaprogramming/inline.md

@@ -235,18 +235,6 @@ inline val four = 4
 inline val four: 4 = 4
 ```
 
-It is also possible to have inline vals of types that do not have a syntax, such as `Short(4)`.
-
-```scala
-trait InlineConstants {
-  inline val myShort: Short
-}
-
-object Constants extends InlineConstants {
-  inline val myShort/*: Short(4)*/ = 4
-}
-```
-
 ## Transparent Inline Methods
 
 Inline methods can additionally be declared `transparent`.
@@ -287,6 +275,15 @@ transparent inline def zero(): Int = 0
 val one: 1 = zero() + 1
 ```
 
+All `inline val`s effectively are transparent. This allows any `inline val` to be costant folded.
+
+```scala
+inline val one: Int = 1
+
+val two: 2 = one + one
+```
+
+
 ## Inline Conditionals
 
 If the condition of an if-then-else expressions is a constant expression then it simplifies to

tests/neg/i8841.check

@@ -1,7 +1,3 @@
--- Error: tests/neg/i8841.scala:2:20 -----------------------------------------------------------------------------------
-2 |  inline val log1 : Boolean = false // error
-  |                    ^^^^^^^
-  |                    inline value must have a literal constant type
 -- Error: tests/neg/i8841.scala:3:20 -----------------------------------------------------------------------------------
 3 |  inline val log2 = true: Boolean // error
   |                    ^^^^^^^^^^^^^

tests/neg/i8841.scala

@@ -1,5 +1,5 @@
 object Foo {
-  inline val log1 : Boolean = false // error
+  inline val log1 : Boolean = false
   inline val log2 = true: Boolean // error
   inline val log3: false  = { println(); false } // error
 }

tests/neg/inline-val.scala

@@ -1,4 +1,4 @@
 
 inline val a = 1 : Int // error
-inline val b: Int = 1 // error
+inline val b: Int = 1
 inline val c = b // error

tests/pos/inline-vals.scala

@@ -21,3 +21,15 @@ object Constants extends InlineConstants {
   inline val myInlinedChar = 'a'
   inline val myInlinedString = "abc"
 }
+
+class Constants2 {
+  inline val myInlinedBoolean: Boolean = true
+  inline val myInlinedByte: Byte = 1
+  inline val myInlinedShort: Short = 2
+  inline val myInlinedInt: Int = 3
+  inline val myInlinedLong: Long = 4
+  inline val myInlinedFloat: Float = 5
+  inline val myInlinedDouble: Double = 6
+  inline val myInlinedChar: Char = 'a'
+  inline val myInlinedString: String = "abc"
+}