Annotations & Visibility

//> using scala 3.10.0

import scala.annotation.tailrec

@tailrec
def bad(n: Int): Int =
  if n == 0 then 0 else 1 + bad(n - 1)

@main def a2(): Unit = println(bad(3))

-- Error: a2.scala:7:31
7 |  if n == 0 then 0 else 1 + bad(n - 1)
  |                            ^^^^^^^^^^
  |                 Cannot rewrite recursive call: it is not in tail position
1 error found
Compilation failed

//> using scala 3.10.0

@deprecated("use plan2", "1.2")
def plan(km: Double): Int = (km * 12).toInt

@main def a3(): Unit = println(plan(2.0))

-- Deprecation Warning: a3.scala:6:31
6 |@main def a3(): Unit = println(plan(2.0))
  |                               ^^^^
  |                            method plan is deprecated since 1.2: use plan2
1 warning found
24

//> using scala 3.10.0
import java.io.IOException

@throws[IOException]
def read(path: String): String =
  if path.isEmpty then throw IOException("empty") else "data"

@main def a5(): Unit =
  println(read("x"))
  val m = Class.forName("a5$package").getMethods.find(_.getName == "read").get
  println(m.getExceptionTypes.toList)

data
List(class java.io.IOException)

//> using scala 3.10.0
import scala.annotation.targetName

object Overloads:
  def add(xs: List[Int]): Int = xs.sum
  def add(xs: List[String]): Int = xs.size

@main def a6(): Unit = ()

-- [E120] Naming Error: a6.scala:6:6
6 |  def add(xs: List[String]): Int = xs.size
  |      ^
  |Conflicting definitions:
  |def add(xs: List[Int]): Int in object Overloads at line 5 and
  |def add(xs: List[String]): Int in object Overloads at line 6
  |have the same type (xs: List): Int after erasure.
  |
  |Consider adding a @targetName annotation to one of the conflicting definitions
  |for disambiguation.

//> using scala 3.10.0

import scala.annotation.{tailrec, targetName, threadUnsafe}

@tailrec
def total(xs: List[Int], acc: Int = 0): Int = xs match
  case Nil => acc
  case h :: t => total(t, acc + h)

object Trails:
  @targetName("addTrail")
  def add(name: String): String = s"+$name"
  @targetName("addTrails")
  def add(names: List[String]): String = names.map(add).mkString(",")

  @threadUnsafe lazy val cache: Map[String, Int] = Map("Aguja" -> 3)

@main def a1(): Unit =
  println(total(List(1, 2, 3)))
  println(Trails.add("a"))
  println(Trails.add(List("a", "b")))
  println(Trails.cache)

6
+a
+a,+b
Map(Aguja -> 3)

//> using scala 3.10.0
import scala.annotation.publicInBinary

class Planner:
  @publicInBinary private[Planner] def speed: Double = 4.5
  inline def minutes(km: Double): Double = km / speed * 60

@main def a11(): Unit = println(Planner().minutes(9.0))

120.0

-- [E029] Pattern Match Exhaustivity Warning: a9.scala:7:19
7 |  val a = xs.map { case i: Int => i }.size       // warning: match may not be exhaustive
  |                   ^
  |                   match may not be exhaustive.
  |
  |                   It would fail on pattern case: _: String

//> using scala 3.10.0
val xs: List[Int | String] = List(1, 2)
@main def a9b(): Unit =
  val b = xs.map { x => (x: @unchecked) match { case i: Int => i } }.sum
  println(b)

3

//> using scala 3.10.0
import scala.annotation.nowarn

@deprecated("use plan2", "1.2")
def plan(km: Double): Int = (km * 12).toInt

@main def a4(): Unit =
  @nowarn("cat=deprecation")
  val r = plan(2.0)
  println(r)
  @nowarn val unused = plan(1.0)       // silences every warning in the annotated tree
  println(unused)

24
12

//> using scala 3.10.0
import scala.annotation.experimental

@experimental def fancy: Int = 1

def user: Int = fancy

@main def a7(): Unit = println(user)

-- Error: a7.scala:6:16
6 |def user: Int = fancy
  |                ^^^^^
  |         method fancy is marked @experimental
  |
  |         Experimental definition may only be used under experimental mode:
  |           1. in a definition marked as @experimental, or
  |           2. an experimental feature is imported at the package level, or
  |           3. compiling with the -experimental compiler flag.
1 error found
Compilation failed

-- Warning: a14.scala:3:9
3 |  private[this] val y = 1
  |         ^^^^^^
  |Ignoring [this] qualifier.
  |The syntax `private[this]` will be deprecated in the future; just write `private` instead.
  |See: https://docs.scala-lang.org/scala3/reference/dropped-features/this-qualifier.html

//> using scala 3.10.0
package trails:
  class Trail(private val grade: Int, protected val ascent: Int):
    private[trails] val internalId = 7

package other:
  import trails.Trail
  @main def a13(): Unit =
    val t = Trail(1, 2)
    println(t.grade)
    println(t.ascent)
    println(t.internalId)

-- [E173] Reference Error: a13.scala:10:14
10 |    println(t.grade)
   |            ^^^^^^^
   |value grade cannot be accessed as a member of (t : trails.Trail) from the top-level definitions in package other.
   |  private value grade can only be accessed from class Trail in package trails.
-- [E173] Reference Error: a13.scala:11:14
11 |    println(t.ascent)
   |            ^^^^^^^^
   |value ascent cannot be accessed as a member of (t : trails.Trail) from the top-level definitions in package other.
   |  protected value ascent can only be accessed from class Trail in package trails or one of its subclasses.
-- [E173] Reference Error: a13.scala:12:14
12 |    println(t.internalId)
   |            ^^^^^^^^^^^^
   |value internalId cannot be accessed as a member of (t : trails.Trail) from the top-level definitions in package other.
   |  private[trails] value internalId can only be accessed from package trails.
3 errors found
Compilation failed

-- [E173] Reference Error: a16.scala:8:24
8 |  def run(t: Trail) = t.audit      // same package, not a subclass
  |                      ^^^^^^^
  |method audit cannot be accessed as a member of (t : trails.Trail) from object Check.
  |  protected method audit can only be accessed from class Trail in package trails or one of its subclasses.

-- [E173] Reference Error: a15.scala:5:21
5 |  def peek(o: A) = o.hidden        // protected: not accessible through a different instance of the superclass
  |                   ^^^^^^^^
  |method hidden cannot be accessed as a member of (o : A) from class B.
  |  protected method hidden can only be accessed from class B or one of its subclasses.